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 | |
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')
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/MessageHeader.cs | 630 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs | 339 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/PBJ.cs | 2104 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Persistence.cs | 3299 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs | 1543 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Physics.cs | 840 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs | 421 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Sirikata.cs | 8074 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs | 3934 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Subscription.cs | 856 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs | 431 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Test.cs | 3773 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Test.pbj.cs | 1761 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Time.cs | 454 | ||||
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Time.pbj.cs | 245 |
15 files changed, 0 insertions, 28704 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 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs b/OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs deleted file mode 100644 index fb4963f..0000000 --- a/OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs +++ /dev/null | |||
@@ -1,339 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace Sirikata.Protocol { | ||
31 | public class Header : PBJ.IMessage { | ||
32 | protected _PBJ_Internal.Header super; | ||
33 | public _PBJ_Internal.Header _PBJSuper{ get { return super;} } | ||
34 | public Header() { | ||
35 | super=new _PBJ_Internal.Header(); | ||
36 | } | ||
37 | public Header(_PBJ_Internal.Header reference) { | ||
38 | super=reference; | ||
39 | } | ||
40 | public static Header defaultInstance= new Header (_PBJ_Internal.Header.DefaultInstance); | ||
41 | public static Header DefaultInstance{ | ||
42 | get {return defaultInstance;} | ||
43 | } | ||
44 | public static pbd.MessageDescriptor Descriptor { | ||
45 | get { return _PBJ_Internal.Header.Descriptor; } } | ||
46 | public static class Types { | ||
47 | public enum ReturnStatus { | ||
48 | SUCCESS=_PBJ_Internal.Header.Types.ReturnStatus.SUCCESS, | ||
49 | NETWORK_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.NETWORK_FAILURE, | ||
50 | TIMEOUT_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.TIMEOUT_FAILURE, | ||
51 | PROTOCOL_ERROR=_PBJ_Internal.Header.Types.ReturnStatus.PROTOCOL_ERROR, | ||
52 | PORT_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.PORT_FAILURE, | ||
53 | UNKNOWN_OBJECT=_PBJ_Internal.Header.Types.ReturnStatus.UNKNOWN_OBJECT | ||
54 | }; | ||
55 | } | ||
56 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
57 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
58 | } | ||
59 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
60 | return false; | ||
61 | } | ||
62 | public const int SourceObjectFieldTag=1; | ||
63 | public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } | ||
64 | public PBJ.UUID SourceObject{ get { | ||
65 | if (HasSourceObject) { | ||
66 | return PBJ._PBJ.CastUuid(super.SourceObject); | ||
67 | } else { | ||
68 | return PBJ._PBJ.CastUuid(); | ||
69 | } | ||
70 | } | ||
71 | } | ||
72 | public const int SourcePortFieldTag=3; | ||
73 | public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } | ||
74 | public uint SourcePort{ get { | ||
75 | if (HasSourcePort) { | ||
76 | return PBJ._PBJ.CastUint32(super.SourcePort); | ||
77 | } else { | ||
78 | return PBJ._PBJ.CastUint32(); | ||
79 | } | ||
80 | } | ||
81 | } | ||
82 | public const int SourceSpaceFieldTag=1536; | ||
83 | public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } | ||
84 | public PBJ.UUID SourceSpace{ get { | ||
85 | if (HasSourceSpace) { | ||
86 | return PBJ._PBJ.CastUuid(super.SourceSpace); | ||
87 | } else { | ||
88 | return PBJ._PBJ.CastUuid(); | ||
89 | } | ||
90 | } | ||
91 | } | ||
92 | public const int DestinationObjectFieldTag=2; | ||
93 | public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } | ||
94 | public PBJ.UUID DestinationObject{ get { | ||
95 | if (HasDestinationObject) { | ||
96 | return PBJ._PBJ.CastUuid(super.DestinationObject); | ||
97 | } else { | ||
98 | return PBJ._PBJ.CastUuid(); | ||
99 | } | ||
100 | } | ||
101 | } | ||
102 | public const int DestinationPortFieldTag=4; | ||
103 | public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } | ||
104 | public uint DestinationPort{ get { | ||
105 | if (HasDestinationPort) { | ||
106 | return PBJ._PBJ.CastUint32(super.DestinationPort); | ||
107 | } else { | ||
108 | return PBJ._PBJ.CastUint32(); | ||
109 | } | ||
110 | } | ||
111 | } | ||
112 | public const int DestinationSpaceFieldTag=1537; | ||
113 | public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } | ||
114 | public PBJ.UUID DestinationSpace{ get { | ||
115 | if (HasDestinationSpace) { | ||
116 | return PBJ._PBJ.CastUuid(super.DestinationSpace); | ||
117 | } else { | ||
118 | return PBJ._PBJ.CastUuid(); | ||
119 | } | ||
120 | } | ||
121 | } | ||
122 | public const int IdFieldTag=7; | ||
123 | public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } | ||
124 | public long Id{ get { | ||
125 | if (HasId) { | ||
126 | return PBJ._PBJ.CastInt64(super.Id); | ||
127 | } else { | ||
128 | return PBJ._PBJ.CastInt64(); | ||
129 | } | ||
130 | } | ||
131 | } | ||
132 | public const int ReplyIdFieldTag=8; | ||
133 | public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } | ||
134 | public long ReplyId{ get { | ||
135 | if (HasReplyId) { | ||
136 | return PBJ._PBJ.CastInt64(super.ReplyId); | ||
137 | } else { | ||
138 | return PBJ._PBJ.CastInt64(); | ||
139 | } | ||
140 | } | ||
141 | } | ||
142 | public const int ReturnStatusFieldTag=1792; | ||
143 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
144 | public Types.ReturnStatus ReturnStatus{ get { | ||
145 | if (HasReturnStatus) { | ||
146 | return (Types.ReturnStatus)super.ReturnStatus; | ||
147 | } else { | ||
148 | return new Types.ReturnStatus(); | ||
149 | } | ||
150 | } | ||
151 | } | ||
152 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
153 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
154 | public static Builder CreateBuilder() { return new Builder(); } | ||
155 | public static Builder CreateBuilder(Header prototype) { | ||
156 | return (Builder)new Builder().MergeFrom(prototype); | ||
157 | } | ||
158 | public static Header ParseFrom(pb::ByteString data) { | ||
159 | return new Header(_PBJ_Internal.Header.ParseFrom(data)); | ||
160 | } | ||
161 | public static Header ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
162 | return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); | ||
163 | } | ||
164 | public static Header ParseFrom(byte[] data) { | ||
165 | return new Header(_PBJ_Internal.Header.ParseFrom(data)); | ||
166 | } | ||
167 | public static Header ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
168 | return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); | ||
169 | } | ||
170 | public static Header ParseFrom(global::System.IO.Stream data) { | ||
171 | return new Header(_PBJ_Internal.Header.ParseFrom(data)); | ||
172 | } | ||
173 | public static Header ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
174 | return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); | ||
175 | } | ||
176 | public static Header ParseFrom(pb::CodedInputStream data) { | ||
177 | return new Header(_PBJ_Internal.Header.ParseFrom(data)); | ||
178 | } | ||
179 | public static Header ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
180 | return new Header(_PBJ_Internal.Header.ParseFrom(data,er)); | ||
181 | } | ||
182 | protected override bool _HasAllPBJFields{ get { | ||
183 | return true | ||
184 | ; | ||
185 | } } | ||
186 | public bool IsInitialized { get { | ||
187 | return super.IsInitialized&&_HasAllPBJFields; | ||
188 | } } | ||
189 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
190 | protected override bool _HasAllPBJFields{ get { | ||
191 | return true | ||
192 | ; | ||
193 | } } | ||
194 | public bool IsInitialized { get { | ||
195 | return super.IsInitialized&&_HasAllPBJFields; | ||
196 | } } | ||
197 | protected _PBJ_Internal.Header.Builder super; | ||
198 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
199 | public _PBJ_Internal.Header.Builder _PBJSuper{ get { return super;} } | ||
200 | public Builder() {super = new _PBJ_Internal.Header.Builder();} | ||
201 | public Builder(_PBJ_Internal.Header.Builder other) { | ||
202 | super=other; | ||
203 | } | ||
204 | public Builder Clone() {return new Builder(super.Clone());} | ||
205 | public Builder MergeFrom(Header prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
206 | public Builder Clear() {super.Clear();return this;} | ||
207 | public Header BuildPartial() {return new Header(super.BuildPartial());} | ||
208 | public Header Build() {if (_HasAllPBJFields) return new Header(super.Build());return null;} | ||
209 | public pbd::MessageDescriptor DescriptorForType { | ||
210 | get { return Header.Descriptor; } } | ||
211 | public Builder ClearSourceObject() { super.ClearSourceObject();return this;} | ||
212 | public const int SourceObjectFieldTag=1; | ||
213 | public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } | ||
214 | public PBJ.UUID SourceObject{ get { | ||
215 | if (HasSourceObject) { | ||
216 | return PBJ._PBJ.CastUuid(super.SourceObject); | ||
217 | } else { | ||
218 | return PBJ._PBJ.CastUuid(); | ||
219 | } | ||
220 | } | ||
221 | set { | ||
222 | super.SourceObject=(PBJ._PBJ.Construct(value)); | ||
223 | } | ||
224 | } | ||
225 | public Builder ClearSourcePort() { super.ClearSourcePort();return this;} | ||
226 | public const int SourcePortFieldTag=3; | ||
227 | public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } | ||
228 | public uint SourcePort{ get { | ||
229 | if (HasSourcePort) { | ||
230 | return PBJ._PBJ.CastUint32(super.SourcePort); | ||
231 | } else { | ||
232 | return PBJ._PBJ.CastUint32(); | ||
233 | } | ||
234 | } | ||
235 | set { | ||
236 | super.SourcePort=(PBJ._PBJ.Construct(value)); | ||
237 | } | ||
238 | } | ||
239 | public Builder ClearSourceSpace() { super.ClearSourceSpace();return this;} | ||
240 | public const int SourceSpaceFieldTag=1536; | ||
241 | public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } | ||
242 | public PBJ.UUID SourceSpace{ get { | ||
243 | if (HasSourceSpace) { | ||
244 | return PBJ._PBJ.CastUuid(super.SourceSpace); | ||
245 | } else { | ||
246 | return PBJ._PBJ.CastUuid(); | ||
247 | } | ||
248 | } | ||
249 | set { | ||
250 | super.SourceSpace=(PBJ._PBJ.Construct(value)); | ||
251 | } | ||
252 | } | ||
253 | public Builder ClearDestinationObject() { super.ClearDestinationObject();return this;} | ||
254 | public const int DestinationObjectFieldTag=2; | ||
255 | public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } | ||
256 | public PBJ.UUID DestinationObject{ get { | ||
257 | if (HasDestinationObject) { | ||
258 | return PBJ._PBJ.CastUuid(super.DestinationObject); | ||
259 | } else { | ||
260 | return PBJ._PBJ.CastUuid(); | ||
261 | } | ||
262 | } | ||
263 | set { | ||
264 | super.DestinationObject=(PBJ._PBJ.Construct(value)); | ||
265 | } | ||
266 | } | ||
267 | public Builder ClearDestinationPort() { super.ClearDestinationPort();return this;} | ||
268 | public const int DestinationPortFieldTag=4; | ||
269 | public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } | ||
270 | public uint DestinationPort{ get { | ||
271 | if (HasDestinationPort) { | ||
272 | return PBJ._PBJ.CastUint32(super.DestinationPort); | ||
273 | } else { | ||
274 | return PBJ._PBJ.CastUint32(); | ||
275 | } | ||
276 | } | ||
277 | set { | ||
278 | super.DestinationPort=(PBJ._PBJ.Construct(value)); | ||
279 | } | ||
280 | } | ||
281 | public Builder ClearDestinationSpace() { super.ClearDestinationSpace();return this;} | ||
282 | public const int DestinationSpaceFieldTag=1537; | ||
283 | public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } | ||
284 | public PBJ.UUID DestinationSpace{ get { | ||
285 | if (HasDestinationSpace) { | ||
286 | return PBJ._PBJ.CastUuid(super.DestinationSpace); | ||
287 | } else { | ||
288 | return PBJ._PBJ.CastUuid(); | ||
289 | } | ||
290 | } | ||
291 | set { | ||
292 | super.DestinationSpace=(PBJ._PBJ.Construct(value)); | ||
293 | } | ||
294 | } | ||
295 | public Builder ClearId() { super.ClearId();return this;} | ||
296 | public const int IdFieldTag=7; | ||
297 | public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } | ||
298 | public long Id{ get { | ||
299 | if (HasId) { | ||
300 | return PBJ._PBJ.CastInt64(super.Id); | ||
301 | } else { | ||
302 | return PBJ._PBJ.CastInt64(); | ||
303 | } | ||
304 | } | ||
305 | set { | ||
306 | super.Id=(PBJ._PBJ.Construct(value)); | ||
307 | } | ||
308 | } | ||
309 | public Builder ClearReplyId() { super.ClearReplyId();return this;} | ||
310 | public const int ReplyIdFieldTag=8; | ||
311 | public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } | ||
312 | public long ReplyId{ get { | ||
313 | if (HasReplyId) { | ||
314 | return PBJ._PBJ.CastInt64(super.ReplyId); | ||
315 | } else { | ||
316 | return PBJ._PBJ.CastInt64(); | ||
317 | } | ||
318 | } | ||
319 | set { | ||
320 | super.ReplyId=(PBJ._PBJ.Construct(value)); | ||
321 | } | ||
322 | } | ||
323 | public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} | ||
324 | public const int ReturnStatusFieldTag=1792; | ||
325 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
326 | public Types.ReturnStatus ReturnStatus{ get { | ||
327 | if (HasReturnStatus) { | ||
328 | return (Types.ReturnStatus)super.ReturnStatus; | ||
329 | } else { | ||
330 | return new Types.ReturnStatus(); | ||
331 | } | ||
332 | } | ||
333 | set { | ||
334 | super.ReturnStatus=((_PBJ_Internal.Header.Types.ReturnStatus)value); | ||
335 | } | ||
336 | } | ||
337 | } | ||
338 | } | ||
339 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/PBJ.cs b/OpenSim/Client/Sirikata/Protocol/PBJ.cs deleted file mode 100644 index 9b1951a..0000000 --- a/OpenSim/Client/Sirikata/Protocol/PBJ.cs +++ /dev/null | |||
@@ -1,2104 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | namespace PBJ | ||
30 | { | ||
31 | |||
32 | public class IMessage | ||
33 | { | ||
34 | public virtual Google.ProtocolBuffers.IMessage _PBJISuper { get { return null; } } | ||
35 | protected virtual bool _HasAllPBJFields { get { return true; } } | ||
36 | public void WriteTo(Google.ProtocolBuffers.CodedOutputStream output) | ||
37 | { | ||
38 | _PBJISuper.WriteTo(output); | ||
39 | } | ||
40 | public override bool Equals(object other) | ||
41 | { | ||
42 | return _PBJISuper.Equals(other); | ||
43 | } | ||
44 | public int SerializedSize { get { return _PBJISuper.SerializedSize; } } | ||
45 | |||
46 | public override int GetHashCode() { return _PBJISuper.GetHashCode(); } | ||
47 | |||
48 | public override string ToString() | ||
49 | { | ||
50 | return _PBJISuper.ToString(); | ||
51 | } | ||
52 | public virtual IBuilder WeakCreateBuilderForType() { return null; } | ||
53 | public Google.ProtocolBuffers.ByteString ToByteString() | ||
54 | { | ||
55 | return _PBJISuper.ToByteString(); | ||
56 | } | ||
57 | public byte[] ToByteArray() | ||
58 | { | ||
59 | return _PBJISuper.ToByteArray(); | ||
60 | } | ||
61 | public void WriteTo(global::System.IO.Stream output) | ||
62 | { | ||
63 | _PBJISuper.WriteTo(output); | ||
64 | } | ||
65 | // Google.ProtocolBuffers.MessageDescriptor DescriptorForType { get {return _PBJISuper.DescriptorForType;} } | ||
66 | public Google.ProtocolBuffers.UnknownFieldSet UnknownFields { get { return _PBJISuper.UnknownFields; } } | ||
67 | public class IBuilder | ||
68 | { | ||
69 | public virtual Google.ProtocolBuffers.IBuilder _PBJISuper { get { return null; } } | ||
70 | protected virtual bool _HasAllPBJFields { get { return true; } } | ||
71 | } | ||
72 | } | ||
73 | |||
74 | public struct Vector2f | ||
75 | { | ||
76 | |||
77 | public float x; | ||
78 | public float y; | ||
79 | |||
80 | |||
81 | public Vector2f(float _x, float _y) | ||
82 | { | ||
83 | x = _x; y = _y; | ||
84 | } | ||
85 | |||
86 | public Vector2f(Vector2f cpy) | ||
87 | { | ||
88 | x = cpy.x; y = cpy.y; | ||
89 | } | ||
90 | |||
91 | |||
92 | public Vector2f Negate() | ||
93 | { | ||
94 | return new Vector2f(-x, -y); | ||
95 | } | ||
96 | |||
97 | public Vector2f Add(Vector2f rhs) | ||
98 | { | ||
99 | return new Vector2f(x + rhs.x, y + rhs.y); | ||
100 | } | ||
101 | |||
102 | public Vector2f Subtract(Vector2f rhs) | ||
103 | { | ||
104 | return new Vector2f(x - rhs.x, y - rhs.y); | ||
105 | } | ||
106 | |||
107 | public Vector2f Multiply(Vector2f rhs) | ||
108 | { | ||
109 | return new Vector2f(x * rhs.x, y * rhs.y); | ||
110 | } | ||
111 | |||
112 | public Vector2f Multiply(float s) | ||
113 | { | ||
114 | return new Vector2f(x * s, y * s); | ||
115 | } | ||
116 | |||
117 | public Vector2f Divide(Vector2f rhs) | ||
118 | { | ||
119 | return new Vector2f(x / rhs.x, y / rhs.y); | ||
120 | } | ||
121 | |||
122 | public Vector2f Divide(float s) | ||
123 | { | ||
124 | return new Vector2f(x / s, y / s); | ||
125 | } | ||
126 | |||
127 | public float Dot(Vector2f rhs) | ||
128 | { | ||
129 | return (x * rhs.x + y * rhs.y); | ||
130 | } | ||
131 | |||
132 | public void Normalize() | ||
133 | { | ||
134 | float len = Length; | ||
135 | if (len != 0.0) | ||
136 | { | ||
137 | x /= len; y /= len; | ||
138 | } | ||
139 | } | ||
140 | |||
141 | public Vector2f Normalized | ||
142 | { | ||
143 | get | ||
144 | { | ||
145 | Vector2f normed = new Vector2f(this); | ||
146 | normed.Normalize(); | ||
147 | return normed; | ||
148 | } | ||
149 | } | ||
150 | |||
151 | public float SquaredLength | ||
152 | { | ||
153 | get | ||
154 | { | ||
155 | return (x * x + y * y); | ||
156 | } | ||
157 | } | ||
158 | public float Length | ||
159 | { | ||
160 | get | ||
161 | { | ||
162 | return (float)Math.Sqrt(SquaredLength); | ||
163 | } | ||
164 | } | ||
165 | |||
166 | |||
167 | public override string ToString() | ||
168 | { | ||
169 | return String.Format("<{0}, {1}>", x, y); | ||
170 | } | ||
171 | |||
172 | |||
173 | public static Vector2f operator -(Vector2f uo) | ||
174 | { | ||
175 | return uo.Negate(); | ||
176 | } | ||
177 | |||
178 | public static Vector2f operator +(Vector2f lhs, Vector2f rhs) | ||
179 | { | ||
180 | return lhs.Add(rhs); | ||
181 | } | ||
182 | |||
183 | public static Vector2f operator -(Vector2f lhs, Vector2f rhs) | ||
184 | { | ||
185 | return lhs.Subtract(rhs); | ||
186 | } | ||
187 | |||
188 | public static Vector2f operator *(Vector2f lhs, Vector2f rhs) | ||
189 | { | ||
190 | return lhs.Multiply(rhs); | ||
191 | } | ||
192 | |||
193 | public static Vector2f operator *(Vector2f lhs, float rhs) | ||
194 | { | ||
195 | return lhs.Multiply(rhs); | ||
196 | } | ||
197 | public static Vector2f operator *(float lhs, Vector2f rhs) | ||
198 | { | ||
199 | return rhs.Multiply(lhs); | ||
200 | } | ||
201 | |||
202 | public static Vector2f operator /(Vector2f lhs, Vector2f rhs) | ||
203 | { | ||
204 | return lhs.Divide(rhs); | ||
205 | } | ||
206 | |||
207 | public static Vector2f operator /(Vector2f lhs, float rhs) | ||
208 | { | ||
209 | return lhs.Divide(rhs); | ||
210 | } | ||
211 | |||
212 | } // struct Vector2f | ||
213 | |||
214 | public struct Vector2d | ||
215 | { | ||
216 | |||
217 | public double x; | ||
218 | public double y; | ||
219 | |||
220 | |||
221 | public Vector2d(double _x, double _y) | ||
222 | { | ||
223 | x = _x; y = _y; | ||
224 | } | ||
225 | |||
226 | public Vector2d(Vector2d cpy) | ||
227 | { | ||
228 | x = cpy.x; y = cpy.y; | ||
229 | } | ||
230 | |||
231 | |||
232 | public Vector2d Negate() | ||
233 | { | ||
234 | return new Vector2d(-x, -y); | ||
235 | } | ||
236 | |||
237 | public Vector2d Add(Vector2d rhs) | ||
238 | { | ||
239 | return new Vector2d(x + rhs.x, y + rhs.y); | ||
240 | } | ||
241 | |||
242 | public Vector2d Subtract(Vector2d rhs) | ||
243 | { | ||
244 | return new Vector2d(x - rhs.x, y - rhs.y); | ||
245 | } | ||
246 | |||
247 | public Vector2d Multiply(Vector2d rhs) | ||
248 | { | ||
249 | return new Vector2d(x * rhs.x, y * rhs.y); | ||
250 | } | ||
251 | |||
252 | public Vector2d Multiply(double s) | ||
253 | { | ||
254 | return new Vector2d(x * s, y * s); | ||
255 | } | ||
256 | |||
257 | public Vector2d Divide(Vector2d rhs) | ||
258 | { | ||
259 | return new Vector2d(x / rhs.x, y / rhs.y); | ||
260 | } | ||
261 | |||
262 | public Vector2d Divide(double s) | ||
263 | { | ||
264 | return new Vector2d(x / s, y / s); | ||
265 | } | ||
266 | |||
267 | public double Dot(Vector2d rhs) | ||
268 | { | ||
269 | return (x * rhs.x + y * rhs.y); | ||
270 | } | ||
271 | |||
272 | public void Normalize() | ||
273 | { | ||
274 | double len = Length; | ||
275 | if (len != 0.0) | ||
276 | { | ||
277 | x /= len; y /= len; | ||
278 | } | ||
279 | } | ||
280 | |||
281 | public Vector2d Normalized | ||
282 | { | ||
283 | get | ||
284 | { | ||
285 | Vector2d normed = new Vector2d(this); | ||
286 | normed.Normalize(); | ||
287 | return normed; | ||
288 | } | ||
289 | } | ||
290 | |||
291 | public double SquaredLength | ||
292 | { | ||
293 | get | ||
294 | { | ||
295 | return (x * x + y * y); | ||
296 | } | ||
297 | } | ||
298 | public double Length | ||
299 | { | ||
300 | get | ||
301 | { | ||
302 | return Math.Sqrt(SquaredLength); | ||
303 | } | ||
304 | } | ||
305 | |||
306 | |||
307 | public override string ToString() | ||
308 | { | ||
309 | return String.Format("<{0}, {1}>", x, y); | ||
310 | } | ||
311 | |||
312 | |||
313 | public static Vector2d operator -(Vector2d uo) | ||
314 | { | ||
315 | return uo.Negate(); | ||
316 | } | ||
317 | |||
318 | public static Vector2d operator +(Vector2d lhs, Vector2d rhs) | ||
319 | { | ||
320 | return lhs.Add(rhs); | ||
321 | } | ||
322 | |||
323 | public static Vector2d operator -(Vector2d lhs, Vector2d rhs) | ||
324 | { | ||
325 | return lhs.Subtract(rhs); | ||
326 | } | ||
327 | |||
328 | public static Vector2d operator *(Vector2d lhs, Vector2d rhs) | ||
329 | { | ||
330 | return lhs.Multiply(rhs); | ||
331 | } | ||
332 | |||
333 | public static Vector2d operator *(Vector2d lhs, double rhs) | ||
334 | { | ||
335 | return lhs.Multiply(rhs); | ||
336 | } | ||
337 | public static Vector2d operator *(double lhs, Vector2d rhs) | ||
338 | { | ||
339 | return rhs.Multiply(lhs); | ||
340 | } | ||
341 | |||
342 | public static Vector2d operator /(Vector2d lhs, Vector2d rhs) | ||
343 | { | ||
344 | return lhs.Divide(rhs); | ||
345 | } | ||
346 | |||
347 | public static Vector2d operator /(Vector2d lhs, double rhs) | ||
348 | { | ||
349 | return lhs.Divide(rhs); | ||
350 | } | ||
351 | |||
352 | } // struct Vector2d | ||
353 | |||
354 | public struct Vector3f | ||
355 | { | ||
356 | |||
357 | public float x; | ||
358 | public float y; | ||
359 | public float z; | ||
360 | |||
361 | |||
362 | public Vector3f(float _x, float _y, float _z) | ||
363 | { | ||
364 | x = _x; y = _y; z = _z; | ||
365 | } | ||
366 | |||
367 | public Vector3f(Vector3f cpy) | ||
368 | { | ||
369 | x = cpy.x; y = cpy.y; z = cpy.z; | ||
370 | } | ||
371 | |||
372 | |||
373 | public Vector3f Negate() | ||
374 | { | ||
375 | return new Vector3f(-x, -y, -z); | ||
376 | } | ||
377 | |||
378 | public Vector3f Add(Vector3f rhs) | ||
379 | { | ||
380 | return new Vector3f(x + rhs.x, y + rhs.y, z + rhs.z); | ||
381 | } | ||
382 | |||
383 | public Vector3f Subtract(Vector3f rhs) | ||
384 | { | ||
385 | return new Vector3f(x - rhs.x, y - rhs.y, z - rhs.z); | ||
386 | } | ||
387 | |||
388 | public Vector3f Multiply(Vector3f rhs) | ||
389 | { | ||
390 | return new Vector3f(x * rhs.x, y * rhs.y, z * rhs.z); | ||
391 | } | ||
392 | |||
393 | public Vector3f Multiply(float s) | ||
394 | { | ||
395 | return new Vector3f(x * s, y * s, z * s); | ||
396 | } | ||
397 | |||
398 | public Vector3f Divide(Vector3f rhs) | ||
399 | { | ||
400 | return new Vector3f(x / rhs.x, y / rhs.y, z / rhs.z); | ||
401 | } | ||
402 | |||
403 | public Vector3f Divide(float s) | ||
404 | { | ||
405 | return new Vector3f(x / s, y / s, z / s); | ||
406 | } | ||
407 | |||
408 | public float Dot(Vector3f rhs) | ||
409 | { | ||
410 | return (x * rhs.x + y * rhs.y + z * rhs.z); | ||
411 | } | ||
412 | |||
413 | public Vector3f Cross(Vector3f rhs) | ||
414 | { | ||
415 | return new Vector3f(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x); | ||
416 | } | ||
417 | |||
418 | public void Normalize() | ||
419 | { | ||
420 | float len = Length; | ||
421 | if (len != 0.0) | ||
422 | { | ||
423 | x /= len; y /= len; z /= len; | ||
424 | } | ||
425 | } | ||
426 | |||
427 | public Vector3f Normalized | ||
428 | { | ||
429 | get | ||
430 | { | ||
431 | Vector3f normed = new Vector3f(this); | ||
432 | normed.Normalize(); | ||
433 | return normed; | ||
434 | } | ||
435 | } | ||
436 | |||
437 | public float SquaredLength | ||
438 | { | ||
439 | get | ||
440 | { | ||
441 | return (x * x + y * y + z * z); | ||
442 | } | ||
443 | } | ||
444 | public float Length | ||
445 | { | ||
446 | get | ||
447 | { | ||
448 | return (float)Math.Sqrt(SquaredLength); | ||
449 | } | ||
450 | } | ||
451 | |||
452 | |||
453 | public override string ToString() | ||
454 | { | ||
455 | return String.Format("<{0}, {1}, {2}>", x, y, z); | ||
456 | } | ||
457 | |||
458 | |||
459 | public static Vector3f operator -(Vector3f uo) | ||
460 | { | ||
461 | return uo.Negate(); | ||
462 | } | ||
463 | |||
464 | public static Vector3f operator +(Vector3f lhs, Vector3f rhs) | ||
465 | { | ||
466 | return lhs.Add(rhs); | ||
467 | } | ||
468 | |||
469 | public static Vector3f operator -(Vector3f lhs, Vector3f rhs) | ||
470 | { | ||
471 | return lhs.Subtract(rhs); | ||
472 | } | ||
473 | |||
474 | public static Vector3f operator *(Vector3f lhs, Vector3f rhs) | ||
475 | { | ||
476 | return lhs.Multiply(rhs); | ||
477 | } | ||
478 | |||
479 | public static Vector3f operator *(Vector3f lhs, float rhs) | ||
480 | { | ||
481 | return lhs.Multiply(rhs); | ||
482 | } | ||
483 | public static Vector3f operator *(float lhs, Vector3f rhs) | ||
484 | { | ||
485 | return rhs.Multiply(lhs); | ||
486 | } | ||
487 | |||
488 | public static Vector3f operator /(Vector3f lhs, Vector3f rhs) | ||
489 | { | ||
490 | return lhs.Divide(rhs); | ||
491 | } | ||
492 | |||
493 | public static Vector3f operator /(Vector3f lhs, float rhs) | ||
494 | { | ||
495 | return lhs.Divide(rhs); | ||
496 | } | ||
497 | |||
498 | } // struct Vector3f | ||
499 | |||
500 | public struct Vector3d | ||
501 | { | ||
502 | |||
503 | public double x; | ||
504 | public double y; | ||
505 | public double z; | ||
506 | |||
507 | |||
508 | public Vector3d(double _x, double _y, double _z) | ||
509 | { | ||
510 | x = _x; y = _y; z = _z; | ||
511 | } | ||
512 | |||
513 | public Vector3d(Vector3d cpy) | ||
514 | { | ||
515 | x = cpy.x; y = cpy.y; z = cpy.z; | ||
516 | } | ||
517 | |||
518 | |||
519 | public Vector3d Negate() | ||
520 | { | ||
521 | return new Vector3d(-x, -y, -z); | ||
522 | } | ||
523 | |||
524 | public Vector3d Add(Vector3d rhs) | ||
525 | { | ||
526 | return new Vector3d(x + rhs.x, y + rhs.y, z + rhs.z); | ||
527 | } | ||
528 | |||
529 | public Vector3d Subtract(Vector3d rhs) | ||
530 | { | ||
531 | return new Vector3d(x - rhs.x, y - rhs.y, z - rhs.z); | ||
532 | } | ||
533 | |||
534 | public Vector3d Multiply(Vector3d rhs) | ||
535 | { | ||
536 | return new Vector3d(x * rhs.x, y * rhs.y, z * rhs.z); | ||
537 | } | ||
538 | |||
539 | public Vector3d Multiply(double s) | ||
540 | { | ||
541 | return new Vector3d(x * s, y * s, z * s); | ||
542 | } | ||
543 | |||
544 | public Vector3d Divide(Vector3d rhs) | ||
545 | { | ||
546 | return new Vector3d(x / rhs.x, y / rhs.y, z / rhs.z); | ||
547 | } | ||
548 | |||
549 | public Vector3d Divide(double s) | ||
550 | { | ||
551 | return new Vector3d(x / s, y / s, z / s); | ||
552 | } | ||
553 | |||
554 | public double Dot(Vector3d rhs) | ||
555 | { | ||
556 | return (x * rhs.x + y * rhs.y + z * rhs.z); | ||
557 | } | ||
558 | |||
559 | public Vector3d Cross(Vector3d rhs) | ||
560 | { | ||
561 | return new Vector3d(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x); | ||
562 | } | ||
563 | |||
564 | public void Normalize() | ||
565 | { | ||
566 | double len = Length; | ||
567 | if (len != 0.0) | ||
568 | { | ||
569 | x /= len; y /= len; z /= len; | ||
570 | } | ||
571 | } | ||
572 | |||
573 | public Vector3d Normalized | ||
574 | { | ||
575 | get | ||
576 | { | ||
577 | Vector3d normed = new Vector3d(this); | ||
578 | normed.Normalize(); | ||
579 | return normed; | ||
580 | } | ||
581 | } | ||
582 | |||
583 | public double SquaredLength | ||
584 | { | ||
585 | get | ||
586 | { | ||
587 | return (x * x + y * y + z * z); | ||
588 | } | ||
589 | } | ||
590 | public double Length | ||
591 | { | ||
592 | get | ||
593 | { | ||
594 | return Math.Sqrt(SquaredLength); | ||
595 | } | ||
596 | } | ||
597 | |||
598 | |||
599 | public override string ToString() | ||
600 | { | ||
601 | return String.Format("<{0}, {1}, {2}>", x, y, z); | ||
602 | } | ||
603 | |||
604 | |||
605 | public static Vector3d operator -(Vector3d uo) | ||
606 | { | ||
607 | return uo.Negate(); | ||
608 | } | ||
609 | |||
610 | public static Vector3d operator +(Vector3d lhs, Vector3d rhs) | ||
611 | { | ||
612 | return lhs.Add(rhs); | ||
613 | } | ||
614 | |||
615 | public static Vector3d operator -(Vector3d lhs, Vector3d rhs) | ||
616 | { | ||
617 | return lhs.Subtract(rhs); | ||
618 | } | ||
619 | |||
620 | public static Vector3d operator *(Vector3d lhs, Vector3d rhs) | ||
621 | { | ||
622 | return lhs.Multiply(rhs); | ||
623 | } | ||
624 | |||
625 | public static Vector3d operator *(Vector3d lhs, double rhs) | ||
626 | { | ||
627 | return lhs.Multiply(rhs); | ||
628 | } | ||
629 | public static Vector3d operator *(double lhs, Vector3d rhs) | ||
630 | { | ||
631 | return rhs.Multiply(lhs); | ||
632 | } | ||
633 | |||
634 | public static Vector3d operator /(Vector3d lhs, Vector3d rhs) | ||
635 | { | ||
636 | return lhs.Divide(rhs); | ||
637 | } | ||
638 | |||
639 | public static Vector3d operator /(Vector3d lhs, double rhs) | ||
640 | { | ||
641 | return lhs.Divide(rhs); | ||
642 | } | ||
643 | |||
644 | } // struct Vector3d | ||
645 | |||
646 | public struct Quaternion | ||
647 | { | ||
648 | |||
649 | public float w; | ||
650 | public float x; | ||
651 | public float y; | ||
652 | public float z; | ||
653 | |||
654 | |||
655 | public Quaternion(float _w, float _x, float _y, float _z) | ||
656 | { | ||
657 | w = _w; x = _x; y = _y; z = _z; | ||
658 | } | ||
659 | |||
660 | public Quaternion(Quaternion cpy) | ||
661 | { | ||
662 | w = cpy.w; x = cpy.x; y = cpy.y; z = cpy.z; | ||
663 | } | ||
664 | |||
665 | public static readonly Quaternion Identity = new Quaternion((float)1.0, (float)0.0, (float)0.0, (float)0.0); | ||
666 | |||
667 | public static Quaternion FromAxisAngle(Vector3f axis, float rads) | ||
668 | { | ||
669 | float halfAngle = rads * 0.5f; | ||
670 | float sinHalf = (float)Math.Sin(halfAngle); | ||
671 | float w = (float)Math.Cos(halfAngle); | ||
672 | float x = sinHalf * axis.x; | ||
673 | float y = sinHalf * axis.y; | ||
674 | float z = sinHalf * axis.z; | ||
675 | return new Quaternion(w, x, y, z); | ||
676 | } | ||
677 | |||
678 | public static Quaternion FromAxisAngle(Vector3d axis, float rads) | ||
679 | { | ||
680 | float halfAngle = rads * 0.5f; | ||
681 | float sinHalf = (float)Math.Sin(halfAngle); | ||
682 | float w = (float)Math.Cos(halfAngle); | ||
683 | float x = (float)(sinHalf * axis.x); | ||
684 | float y = (float)(sinHalf * axis.y); | ||
685 | float z = (float)(sinHalf * axis.z); | ||
686 | return new Quaternion(w, x, y, z); | ||
687 | } | ||
688 | |||
689 | |||
690 | public Quaternion Add(Quaternion rhs) | ||
691 | { | ||
692 | return new Quaternion(w + rhs.w, x + rhs.x, y + rhs.y, z + rhs.z); | ||
693 | } | ||
694 | |||
695 | public Quaternion Subtract(Quaternion rhs) | ||
696 | { | ||
697 | return new Quaternion(w - rhs.w, x - rhs.x, y - rhs.y, z - rhs.z); | ||
698 | } | ||
699 | |||
700 | public Quaternion Multiply(Quaternion rhs) | ||
701 | { | ||
702 | return new Quaternion( | ||
703 | w * rhs.w - x * rhs.x - y * rhs.y - z * rhs.z, | ||
704 | w * rhs.x + x * rhs.w + y * rhs.z - z * rhs.y, | ||
705 | w * rhs.y + y * rhs.w + z * rhs.x - x * rhs.z, | ||
706 | w * rhs.z + z * rhs.w + x * rhs.y - y * rhs.x | ||
707 | ); | ||
708 | } | ||
709 | |||
710 | public Vector3f Multiply(Vector3f rhs) | ||
711 | { | ||
712 | Vector3f qvec = new Vector3f(x, y, z); | ||
713 | Vector3f uv = qvec.Cross(rhs); | ||
714 | Vector3f uuv = qvec.Cross(uv); | ||
715 | uv *= 2.0f * w; | ||
716 | uuv *= 2.0f; | ||
717 | |||
718 | return rhs + uv + uuv; | ||
719 | } | ||
720 | |||
721 | public Vector3d Multiply(Vector3d rhs) | ||
722 | { | ||
723 | Vector3d qvec = new Vector3d(x, y, z); | ||
724 | Vector3d uv = qvec.Cross(rhs); | ||
725 | Vector3d uuv = qvec.Cross(uv); | ||
726 | uv *= 2.0f * w; | ||
727 | uuv *= 2.0f; | ||
728 | |||
729 | return rhs + uv + uuv; | ||
730 | } | ||
731 | |||
732 | public Quaternion Multiply(float rhs) | ||
733 | { | ||
734 | return new Quaternion(w * rhs, x * rhs, y * rhs, z * rhs); | ||
735 | } | ||
736 | |||
737 | public Quaternion Negate() | ||
738 | { | ||
739 | return new Quaternion(-w, -x, -y, -z); | ||
740 | } | ||
741 | |||
742 | public float Dot(Quaternion rhs) | ||
743 | { | ||
744 | return (w * rhs.w + x * rhs.x + y * rhs.y + z * rhs.z); | ||
745 | } | ||
746 | |||
747 | public float Norm | ||
748 | { | ||
749 | get | ||
750 | { | ||
751 | return (float)Math.Sqrt(w * w + x * x + y * y + z * z); | ||
752 | } | ||
753 | } | ||
754 | |||
755 | public float SquareNorm | ||
756 | { | ||
757 | get | ||
758 | { | ||
759 | return (w * w + x * x + y * y + z * z); | ||
760 | } | ||
761 | } | ||
762 | |||
763 | public void Normalize() | ||
764 | { | ||
765 | float len = SquareNorm; | ||
766 | if (len == 0.0) return; | ||
767 | float factor = 1.0f / (float)Math.Sqrt(len); | ||
768 | this *= factor; | ||
769 | } | ||
770 | |||
771 | public Quaternion Normalized | ||
772 | { | ||
773 | get | ||
774 | { | ||
775 | Quaternion q = new Quaternion(this); | ||
776 | q.Normalize(); | ||
777 | return q; | ||
778 | } | ||
779 | } | ||
780 | |||
781 | public Quaternion Inverse | ||
782 | { | ||
783 | get | ||
784 | { | ||
785 | float norm = SquareNorm; | ||
786 | if (norm > 0.0) | ||
787 | { | ||
788 | double invnorm = 1.0 / norm; | ||
789 | return new Quaternion((float)(w * invnorm), (float)(-x * invnorm), (float)(-y * invnorm), (float)(-z * invnorm)); | ||
790 | } | ||
791 | else | ||
792 | return new Quaternion((float)0.0, 0.0f, 0.0f, 0.0f); | ||
793 | } | ||
794 | } | ||
795 | |||
796 | |||
797 | public override string ToString() | ||
798 | { | ||
799 | return String.Format("<{0}, {1}, {2}, {3}>", w, x, y, z); | ||
800 | } | ||
801 | |||
802 | |||
803 | |||
804 | public static Quaternion operator -(Quaternion uo) | ||
805 | { | ||
806 | return uo.Negate(); | ||
807 | } | ||
808 | |||
809 | public static Quaternion operator +(Quaternion lhs, Quaternion rhs) | ||
810 | { | ||
811 | return lhs.Add(rhs); | ||
812 | } | ||
813 | |||
814 | public static Quaternion operator -(Quaternion lhs, Quaternion rhs) | ||
815 | { | ||
816 | return lhs.Subtract(rhs); | ||
817 | } | ||
818 | |||
819 | public static Vector3f operator *(Quaternion lhs, Vector3f rhs) | ||
820 | { | ||
821 | return lhs.Multiply(rhs); | ||
822 | } | ||
823 | |||
824 | public static Vector3d operator *(Quaternion lhs, Vector3d rhs) | ||
825 | { | ||
826 | return lhs.Multiply(rhs); | ||
827 | } | ||
828 | |||
829 | public static Quaternion operator *(Quaternion lhs, Quaternion rhs) | ||
830 | { | ||
831 | return lhs.Multiply(rhs); | ||
832 | } | ||
833 | |||
834 | public static Quaternion operator *(Quaternion lhs, float rhs) | ||
835 | { | ||
836 | return lhs.Multiply(rhs); | ||
837 | } | ||
838 | |||
839 | public static Quaternion operator *(float lhs, Quaternion rhs) | ||
840 | { | ||
841 | return rhs.Multiply(lhs); | ||
842 | } | ||
843 | |||
844 | } // struct Quaternion | ||
845 | |||
846 | |||
847 | public struct Vector4f | ||
848 | { | ||
849 | |||
850 | public float x; | ||
851 | public float y; | ||
852 | public float z; | ||
853 | public float w; | ||
854 | |||
855 | |||
856 | public Vector4f(float _x, float _y, float _z, float _w) | ||
857 | { | ||
858 | x = _x; y = _y; z = _z; w = _w; | ||
859 | } | ||
860 | |||
861 | public Vector4f(Vector4f cpy) | ||
862 | { | ||
863 | x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w; | ||
864 | } | ||
865 | |||
866 | |||
867 | public Vector4f Negate() | ||
868 | { | ||
869 | return new Vector4f(-x, -y, -z, -w); | ||
870 | } | ||
871 | |||
872 | public Vector4f Add(Vector4f rhs) | ||
873 | { | ||
874 | return new Vector4f(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w); | ||
875 | } | ||
876 | |||
877 | public Vector4f Subtract(Vector4f rhs) | ||
878 | { | ||
879 | return new Vector4f(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w); | ||
880 | } | ||
881 | |||
882 | public Vector4f Multiply(Vector4f rhs) | ||
883 | { | ||
884 | return new Vector4f(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w); | ||
885 | } | ||
886 | |||
887 | public Vector4f Multiply(float s) | ||
888 | { | ||
889 | return new Vector4f(x * s, y * s, z * s, w * s); | ||
890 | } | ||
891 | |||
892 | public Vector4f Divide(Vector4f rhs) | ||
893 | { | ||
894 | return new Vector4f(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w); | ||
895 | } | ||
896 | |||
897 | public Vector4f Divide(float s) | ||
898 | { | ||
899 | return new Vector4f(x / s, y / s, z / s, w / s); | ||
900 | } | ||
901 | |||
902 | public float Dot(Vector4f rhs) | ||
903 | { | ||
904 | return (x * rhs.x + y * rhs.y + z * rhs.z + w * rhs.w); | ||
905 | } | ||
906 | |||
907 | public void Normalize() | ||
908 | { | ||
909 | float len = Length; | ||
910 | if (len != 0.0) | ||
911 | { | ||
912 | x /= len; y /= len; z /= len; w /= len; | ||
913 | } | ||
914 | } | ||
915 | |||
916 | public Vector4f Normalized | ||
917 | { | ||
918 | get | ||
919 | { | ||
920 | Vector4f normed = new Vector4f(this); | ||
921 | normed.Normalize(); | ||
922 | return normed; | ||
923 | } | ||
924 | } | ||
925 | |||
926 | public float SquaredLength | ||
927 | { | ||
928 | get | ||
929 | { | ||
930 | return (x * x + y * y + z * z + w * w); | ||
931 | } | ||
932 | } | ||
933 | public float Length | ||
934 | { | ||
935 | get | ||
936 | { | ||
937 | return (float)Math.Sqrt(SquaredLength); | ||
938 | } | ||
939 | } | ||
940 | |||
941 | |||
942 | public override string ToString() | ||
943 | { | ||
944 | return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w); | ||
945 | } | ||
946 | |||
947 | |||
948 | public static Vector4f operator -(Vector4f uo) | ||
949 | { | ||
950 | return uo.Negate(); | ||
951 | } | ||
952 | |||
953 | public static Vector4f operator +(Vector4f lhs, Vector4f rhs) | ||
954 | { | ||
955 | return lhs.Add(rhs); | ||
956 | } | ||
957 | |||
958 | public static Vector4f operator -(Vector4f lhs, Vector4f rhs) | ||
959 | { | ||
960 | return lhs.Subtract(rhs); | ||
961 | } | ||
962 | |||
963 | public static Vector4f operator *(Vector4f lhs, Vector4f rhs) | ||
964 | { | ||
965 | return lhs.Multiply(rhs); | ||
966 | } | ||
967 | |||
968 | public static Vector4f operator *(Vector4f lhs, float rhs) | ||
969 | { | ||
970 | return lhs.Multiply(rhs); | ||
971 | } | ||
972 | public static Vector4f operator *(float lhs, Vector4f rhs) | ||
973 | { | ||
974 | return rhs.Multiply(lhs); | ||
975 | } | ||
976 | |||
977 | public static Vector4f operator /(Vector4f lhs, Vector4f rhs) | ||
978 | { | ||
979 | return lhs.Divide(rhs); | ||
980 | } | ||
981 | |||
982 | public static Vector4f operator /(Vector4f lhs, float rhs) | ||
983 | { | ||
984 | return lhs.Divide(rhs); | ||
985 | } | ||
986 | |||
987 | } // struct Vector4f | ||
988 | |||
989 | |||
990 | |||
991 | public struct Vector4d | ||
992 | { | ||
993 | |||
994 | public double x; | ||
995 | public double y; | ||
996 | public double z; | ||
997 | public double w; | ||
998 | |||
999 | |||
1000 | public Vector4d(double _x, double _y, double _z, double _w) | ||
1001 | { | ||
1002 | x = _x; y = _y; z = _z; w = _w; | ||
1003 | } | ||
1004 | |||
1005 | public Vector4d(Vector4d cpy) | ||
1006 | { | ||
1007 | x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w; | ||
1008 | } | ||
1009 | |||
1010 | |||
1011 | public Vector4d Negate() | ||
1012 | { | ||
1013 | return new Vector4d(-x, -y, -z, -w); | ||
1014 | } | ||
1015 | |||
1016 | public Vector4d Add(Vector4d rhs) | ||
1017 | { | ||
1018 | return new Vector4d(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w); | ||
1019 | } | ||
1020 | |||
1021 | public Vector4d Subtract(Vector4d rhs) | ||
1022 | { | ||
1023 | return new Vector4d(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w); | ||
1024 | } | ||
1025 | |||
1026 | public Vector4d Multiply(Vector4d rhs) | ||
1027 | { | ||
1028 | return new Vector4d(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w); | ||
1029 | } | ||
1030 | |||
1031 | public Vector4d Multiply(double s) | ||
1032 | { | ||
1033 | return new Vector4d(x * s, y * s, z * s, w * s); | ||
1034 | } | ||
1035 | |||
1036 | public Vector4d Divide(Vector4d rhs) | ||
1037 | { | ||
1038 | return new Vector4d(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w); | ||
1039 | } | ||
1040 | |||
1041 | public Vector4d Divide(double s) | ||
1042 | { | ||
1043 | return new Vector4d(x / s, y / s, z / s, w / s); | ||
1044 | } | ||
1045 | |||
1046 | public double Dot(Vector4d rhs) | ||
1047 | { | ||
1048 | return (x * rhs.x + y * rhs.y + z * rhs.z + w * rhs.w); | ||
1049 | } | ||
1050 | |||
1051 | public void Normalize() | ||
1052 | { | ||
1053 | double len = Length; | ||
1054 | if (len != 0.0) | ||
1055 | { | ||
1056 | x /= len; y /= len; z /= len; w /= len; | ||
1057 | } | ||
1058 | } | ||
1059 | |||
1060 | public Vector4d Normalized | ||
1061 | { | ||
1062 | get | ||
1063 | { | ||
1064 | Vector4d normed = new Vector4d(this); | ||
1065 | normed.Normalize(); | ||
1066 | return normed; | ||
1067 | } | ||
1068 | } | ||
1069 | |||
1070 | public double SquaredLength | ||
1071 | { | ||
1072 | get | ||
1073 | { | ||
1074 | return (x * x + y * y + z * z + w * w); | ||
1075 | } | ||
1076 | } | ||
1077 | public double Length | ||
1078 | { | ||
1079 | get | ||
1080 | { | ||
1081 | return Math.Sqrt(SquaredLength); | ||
1082 | } | ||
1083 | } | ||
1084 | |||
1085 | |||
1086 | public override string ToString() | ||
1087 | { | ||
1088 | return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w); | ||
1089 | } | ||
1090 | |||
1091 | |||
1092 | public static Vector4d operator -(Vector4d uo) | ||
1093 | { | ||
1094 | return uo.Negate(); | ||
1095 | } | ||
1096 | |||
1097 | public static Vector4d operator +(Vector4d lhs, Vector4d rhs) | ||
1098 | { | ||
1099 | return lhs.Add(rhs); | ||
1100 | } | ||
1101 | |||
1102 | public static Vector4d operator -(Vector4d lhs, Vector4d rhs) | ||
1103 | { | ||
1104 | return lhs.Subtract(rhs); | ||
1105 | } | ||
1106 | |||
1107 | public static Vector4d operator *(Vector4d lhs, Vector4d rhs) | ||
1108 | { | ||
1109 | return lhs.Multiply(rhs); | ||
1110 | } | ||
1111 | |||
1112 | public static Vector4d operator *(Vector4d lhs, double rhs) | ||
1113 | { | ||
1114 | return lhs.Multiply(rhs); | ||
1115 | } | ||
1116 | public static Vector4d operator *(double lhs, Vector4d rhs) | ||
1117 | { | ||
1118 | return rhs.Multiply(lhs); | ||
1119 | } | ||
1120 | |||
1121 | public static Vector4d operator /(Vector4d lhs, Vector4d rhs) | ||
1122 | { | ||
1123 | return lhs.Divide(rhs); | ||
1124 | } | ||
1125 | |||
1126 | public static Vector4d operator /(Vector4d lhs, double rhs) | ||
1127 | { | ||
1128 | return lhs.Divide(rhs); | ||
1129 | } | ||
1130 | |||
1131 | } // struct Vector4d | ||
1132 | |||
1133 | |||
1134 | |||
1135 | public struct BoundingBox3f3f | ||
1136 | { | ||
1137 | Vector3f mMin; | ||
1138 | Vector3f mDiag; | ||
1139 | public BoundingBox3f3f(float minx, float miny, float minz, float diagx, float diagy, float diagz) | ||
1140 | { | ||
1141 | mMin.x = minx; | ||
1142 | mMin.y = miny; | ||
1143 | mMin.z = minz; | ||
1144 | |||
1145 | mDiag.x = diagx; | ||
1146 | mDiag.y = diagy; | ||
1147 | mDiag.z = diagz; | ||
1148 | } | ||
1149 | public BoundingBox3f3f(Vector3f min, Vector3f max) | ||
1150 | { | ||
1151 | mMin = min; | ||
1152 | mDiag = (max - min); | ||
1153 | } | ||
1154 | public BoundingBox3f3f(BoundingBox3f3f cpy, Vector3f scale) | ||
1155 | { | ||
1156 | mMin.x = (float)(cpy.mMin.x * scale.x); | ||
1157 | mMin.y = (float)(cpy.mMin.y * scale.y); | ||
1158 | mMin.z = (float)(cpy.mMin.z * scale.z); | ||
1159 | |||
1160 | mDiag.x = (float)(cpy.mDiag.x * scale.x); | ||
1161 | mDiag.y = (float)(cpy.mDiag.y * scale.y); | ||
1162 | mDiag.z = (float)(cpy.mDiag.z * scale.z); | ||
1163 | } | ||
1164 | public Vector3f Min | ||
1165 | { | ||
1166 | get | ||
1167 | { | ||
1168 | return new Vector3f(mMin.x, mMin.y, mMin.z); | ||
1169 | } | ||
1170 | } | ||
1171 | public Vector3f Max | ||
1172 | { | ||
1173 | get | ||
1174 | { | ||
1175 | return new Vector3f(mMin.x + mDiag.x, mMin.y + mDiag.y, mMin.z + mDiag.z); | ||
1176 | } | ||
1177 | } | ||
1178 | |||
1179 | public Vector3f Diag | ||
1180 | { | ||
1181 | get | ||
1182 | { | ||
1183 | return new Vector3f(mDiag.x, mDiag.y, mDiag.z); | ||
1184 | } | ||
1185 | } | ||
1186 | |||
1187 | |||
1188 | public override string ToString() | ||
1189 | { | ||
1190 | return "[" + this.Min.ToString() + " - " + this.Max.ToString() + "]"; | ||
1191 | } | ||
1192 | public BoundingBox3f3f Merge(BoundingBox3f3f other) | ||
1193 | { | ||
1194 | Vector3f thisMax = Max; | ||
1195 | Vector3f otherMax = other.Max; | ||
1196 | bool xless = other.mMin.x > mMin.x; | ||
1197 | bool yless = other.mMin.y > mMin.y; | ||
1198 | bool zless = other.mMin.z > mMin.z; | ||
1199 | |||
1200 | bool xmore = otherMax.x < thisMax.x; | ||
1201 | bool ymore = otherMax.y < thisMax.y; | ||
1202 | bool zmore = otherMax.z < thisMax.z; | ||
1203 | return new BoundingBox3f3f(xless ? mMin.x : other.mMin.x, | ||
1204 | yless ? mMin.y : other.mMin.y, | ||
1205 | zless ? mMin.z : other.mMin.z, | ||
1206 | xmore ? (xless ? mDiag.x : otherMax.x - mMin.x) : (xless ? thisMax.x - other.mMin.x : other.mDiag.x), | ||
1207 | ymore ? (yless ? mDiag.y : otherMax.y - mMin.y) : (yless ? thisMax.y - other.mMin.y : other.mDiag.y), | ||
1208 | zmore ? (zless ? mDiag.z : otherMax.z - mMin.z) : (zless ? thisMax.z - other.mMin.z : other.mDiag.z)); | ||
1209 | } | ||
1210 | |||
1211 | } // struct BoundingBox | ||
1212 | |||
1213 | public struct BoundingBox3d3f | ||
1214 | { | ||
1215 | Vector3d mMin; | ||
1216 | Vector3f mDiag; | ||
1217 | public BoundingBox3d3f(double minx, double miny, double minz, float diagx, float diagy, float diagz) | ||
1218 | { | ||
1219 | mMin.x = minx; | ||
1220 | mMin.y = miny; | ||
1221 | mMin.z = minz; | ||
1222 | |||
1223 | mDiag.x = diagx; | ||
1224 | mDiag.y = diagy; | ||
1225 | mDiag.z = diagz; | ||
1226 | } | ||
1227 | public BoundingBox3d3f(Vector3d min, Vector3f max) | ||
1228 | { | ||
1229 | mMin = min; | ||
1230 | |||
1231 | mDiag = new Vector3f((float)(max.x - min.x), | ||
1232 | (float)(max.y - min.y), | ||
1233 | (float)(max.z - min.z)); | ||
1234 | } | ||
1235 | public BoundingBox3d3f(BoundingBox3d3f cpy, Vector3d scale) | ||
1236 | { | ||
1237 | mMin.x = (double)(cpy.mMin.x * scale.x); | ||
1238 | mMin.y = (double)(cpy.mMin.y * scale.y); | ||
1239 | mMin.z = (double)(cpy.mMin.z * scale.z); | ||
1240 | |||
1241 | mDiag.x = (float)(cpy.mDiag.x * scale.x); | ||
1242 | mDiag.y = (float)(cpy.mDiag.y * scale.y); | ||
1243 | mDiag.z = (float)(cpy.mDiag.z * scale.z); | ||
1244 | } | ||
1245 | public Vector3d Min | ||
1246 | { | ||
1247 | get | ||
1248 | { | ||
1249 | return new Vector3d(mMin.x, mMin.y, mMin.z); | ||
1250 | } | ||
1251 | } | ||
1252 | public Vector3d Max | ||
1253 | { | ||
1254 | get | ||
1255 | { | ||
1256 | return new Vector3d(mMin.x + mDiag.x, mMin.y + mDiag.y, mMin.z + mDiag.z); | ||
1257 | } | ||
1258 | } | ||
1259 | |||
1260 | public Vector3d Diag | ||
1261 | { | ||
1262 | get | ||
1263 | { | ||
1264 | return new Vector3d(mDiag.x, mDiag.y, mDiag.z); | ||
1265 | } | ||
1266 | } | ||
1267 | |||
1268 | |||
1269 | public override string ToString() | ||
1270 | { | ||
1271 | return "[" + this.Min.ToString() + " - " + this.Max.ToString() + "]"; | ||
1272 | } | ||
1273 | public BoundingBox3d3f Merge(BoundingBox3d3f other) | ||
1274 | { | ||
1275 | Vector3d thisMax = Max; | ||
1276 | Vector3d otherMax = other.Max; | ||
1277 | bool xless = other.mMin.x > mMin.x; | ||
1278 | bool yless = other.mMin.y > mMin.y; | ||
1279 | bool zless = other.mMin.z > mMin.z; | ||
1280 | |||
1281 | bool xmore = otherMax.x < thisMax.x; | ||
1282 | bool ymore = otherMax.y < thisMax.y; | ||
1283 | bool zmore = otherMax.z < thisMax.z; | ||
1284 | return new BoundingBox3d3f(xless ? mMin.x : other.mMin.x, | ||
1285 | yless ? mMin.y : other.mMin.y, | ||
1286 | zless ? mMin.z : other.mMin.z, | ||
1287 | (float)(xmore ? (xless ? mDiag.x : otherMax.x - mMin.x) : (xless ? thisMax.x - other.mMin.x : other.mDiag.x)), | ||
1288 | (float)(ymore ? (yless ? mDiag.y : otherMax.y - mMin.y) : (yless ? thisMax.y - other.mMin.y : other.mDiag.y)), | ||
1289 | (float)(zmore ? (zless ? mDiag.z : otherMax.z - mMin.z) : (zless ? thisMax.z - other.mMin.z : other.mDiag.z))); | ||
1290 | } | ||
1291 | |||
1292 | } // struct BoundingBox | ||
1293 | |||
1294 | |||
1295 | |||
1296 | |||
1297 | public struct BoundingSphere3f | ||
1298 | { | ||
1299 | Vector3f mCenter; | ||
1300 | float mRadius; | ||
1301 | public BoundingSphere3f(float x, float y, float z, float r) | ||
1302 | { | ||
1303 | mCenter = new Vector3f(x, y, z); | ||
1304 | mRadius = r; | ||
1305 | } | ||
1306 | public BoundingSphere3f(Vector3f center, float radius) | ||
1307 | { | ||
1308 | mCenter = center; | ||
1309 | mRadius = radius; | ||
1310 | } | ||
1311 | public BoundingSphere3f(BoundingSphere3f cpy, float scale) | ||
1312 | { | ||
1313 | mCenter = cpy.mCenter; | ||
1314 | mRadius = cpy.mRadius * scale; | ||
1315 | } | ||
1316 | public Vector3f Center | ||
1317 | { | ||
1318 | get | ||
1319 | { | ||
1320 | return new Vector3f(mCenter.x, mCenter.y, mCenter.z); | ||
1321 | } | ||
1322 | } | ||
1323 | public float Radius | ||
1324 | { | ||
1325 | get | ||
1326 | { | ||
1327 | return mRadius; | ||
1328 | } | ||
1329 | } | ||
1330 | |||
1331 | public override string ToString() | ||
1332 | { | ||
1333 | return "[" + this.Center.ToString() + " : " + this.Radius.ToString() + "]"; | ||
1334 | } | ||
1335 | } // struct BoundingSphere3f | ||
1336 | |||
1337 | |||
1338 | |||
1339 | public struct BoundingSphere3d | ||
1340 | { | ||
1341 | Vector3d mCenter; | ||
1342 | float mRadius; | ||
1343 | public BoundingSphere3d(double x, double y, double z, float r) | ||
1344 | { | ||
1345 | mCenter.x = x; | ||
1346 | mCenter.y = y; | ||
1347 | mCenter.z = z; | ||
1348 | mRadius = r; | ||
1349 | } | ||
1350 | public BoundingSphere3d(Vector3d center, float radius) | ||
1351 | { | ||
1352 | mCenter = center; | ||
1353 | mRadius = radius; | ||
1354 | } | ||
1355 | public BoundingSphere3d(BoundingSphere3d cpy, float scale) | ||
1356 | { | ||
1357 | mCenter = cpy.mCenter; | ||
1358 | mRadius = cpy.mRadius * scale; | ||
1359 | } | ||
1360 | public Vector3d Center | ||
1361 | { | ||
1362 | get | ||
1363 | { | ||
1364 | return new Vector3d(mCenter.x, mCenter.y, mCenter.z); | ||
1365 | } | ||
1366 | } | ||
1367 | public float Radius | ||
1368 | { | ||
1369 | get | ||
1370 | { | ||
1371 | return mRadius; | ||
1372 | } | ||
1373 | } | ||
1374 | |||
1375 | public override string ToString() | ||
1376 | { | ||
1377 | return "[" + this.Center.ToString() + " : " + this.Radius.ToString() + "]"; | ||
1378 | } | ||
1379 | } // struct BoundingSphere3f | ||
1380 | |||
1381 | public struct UUID | ||
1382 | { | ||
1383 | ulong mLowOrderBytes; | ||
1384 | ulong mHighOrderBytes; | ||
1385 | |||
1386 | |||
1387 | static ulong SetUUIDlow(Google.ProtocolBuffers.ByteString data, int offset) | ||
1388 | { | ||
1389 | ulong LowOrderBytes = 0; | ||
1390 | int shiftVal = 0; | ||
1391 | for (int i = 0; i < 8; ++i) | ||
1392 | { | ||
1393 | ulong temp = data[i]; | ||
1394 | LowOrderBytes |= (temp << shiftVal); | ||
1395 | shiftVal += 8; | ||
1396 | } | ||
1397 | return LowOrderBytes; | ||
1398 | } | ||
1399 | static ulong SetUUIDhigh(Google.ProtocolBuffers.ByteString data) | ||
1400 | { | ||
1401 | return SetUUIDlow(data, 8); | ||
1402 | } | ||
1403 | static ulong SetUUIDlow(byte[] data, int offset) | ||
1404 | { | ||
1405 | ulong LowOrderBytes = 0; | ||
1406 | int shiftVal = 0; | ||
1407 | for (int i = 0; i < 8; ++i) | ||
1408 | { | ||
1409 | ulong temp = data[i]; | ||
1410 | LowOrderBytes |= (temp << shiftVal); | ||
1411 | shiftVal += 8; | ||
1412 | } | ||
1413 | return LowOrderBytes; | ||
1414 | } | ||
1415 | static ulong SetUUIDhigh(byte[] data) | ||
1416 | { | ||
1417 | return SetUUIDlow(data, 8); | ||
1418 | } | ||
1419 | public bool SetUUID(byte[] data) | ||
1420 | { | ||
1421 | if (data.Length == 16) | ||
1422 | { | ||
1423 | mLowOrderBytes = 0; | ||
1424 | mHighOrderBytes = 0; | ||
1425 | mLowOrderBytes = SetUUIDlow(data, 0); | ||
1426 | mHighOrderBytes = SetUUIDlow(data, 8); | ||
1427 | return true; | ||
1428 | } | ||
1429 | else | ||
1430 | { | ||
1431 | return false; | ||
1432 | } | ||
1433 | } | ||
1434 | public byte[] GetUUID() | ||
1435 | { | ||
1436 | byte[] data = new byte[16]; | ||
1437 | int shiftVal = 0; | ||
1438 | for (int i = 0; i < 8; ++i) | ||
1439 | { | ||
1440 | ulong temp = 0xff; | ||
1441 | temp = (mLowOrderBytes & (temp << shiftVal)); | ||
1442 | temp = (temp >> shiftVal); | ||
1443 | data[i] = (byte)temp; | ||
1444 | shiftVal += 8; | ||
1445 | } | ||
1446 | shiftVal = 0; | ||
1447 | for (int i = 8; i < 16; ++i) | ||
1448 | { | ||
1449 | ulong temp = 0xff; | ||
1450 | temp = (mHighOrderBytes & (temp << shiftVal)); | ||
1451 | temp = (temp >> shiftVal); | ||
1452 | data[i] = (byte)temp; | ||
1453 | shiftVal += 8; | ||
1454 | } | ||
1455 | return data; | ||
1456 | } | ||
1457 | |||
1458 | public static UUID Empty = new UUID(new byte[16]); | ||
1459 | public UUID(byte[] data) | ||
1460 | { | ||
1461 | if (data.Length != 16) | ||
1462 | { | ||
1463 | throw new System.ArgumentException("UUIDs must be provided 16 bytes"); | ||
1464 | } | ||
1465 | mLowOrderBytes = SetUUIDlow(data, 0); | ||
1466 | mHighOrderBytes = SetUUIDhigh(data); | ||
1467 | } | ||
1468 | public UUID(Google.ProtocolBuffers.ByteString data) | ||
1469 | { | ||
1470 | if (data.Length != 16) | ||
1471 | { | ||
1472 | throw new System.ArgumentException("UUIDs must be provided 16 bytes"); | ||
1473 | } | ||
1474 | mLowOrderBytes = SetUUIDlow(data, 0); | ||
1475 | mHighOrderBytes = SetUUIDhigh(data); | ||
1476 | } | ||
1477 | |||
1478 | } | ||
1479 | |||
1480 | |||
1481 | public struct SHA256 | ||
1482 | { | ||
1483 | ulong mLowOrderBytes; | ||
1484 | ulong mLowMediumOrderBytes; | ||
1485 | ulong mMediumHighOrderBytes; | ||
1486 | ulong mHighOrderBytes; | ||
1487 | |||
1488 | |||
1489 | static ulong SetLMH(Google.ProtocolBuffers.ByteString data, int offset) | ||
1490 | { | ||
1491 | ulong LowOrderBytes = 0; | ||
1492 | int shiftVal = 0; | ||
1493 | for (int i = 0; i < 8; ++i) | ||
1494 | { | ||
1495 | ulong temp = data[i]; | ||
1496 | LowOrderBytes |= (temp << shiftVal); | ||
1497 | shiftVal += 8; | ||
1498 | } | ||
1499 | return LowOrderBytes; | ||
1500 | } | ||
1501 | static ulong SetLow(Google.ProtocolBuffers.ByteString data) | ||
1502 | { | ||
1503 | return SetLMH(data, 0); | ||
1504 | } | ||
1505 | static ulong SetLowMedium(Google.ProtocolBuffers.ByteString data) | ||
1506 | { | ||
1507 | return SetLMH(data, 8); | ||
1508 | } | ||
1509 | static ulong SetMediumHigh(Google.ProtocolBuffers.ByteString data) | ||
1510 | { | ||
1511 | return SetLMH(data, 16); | ||
1512 | } | ||
1513 | static ulong SetHigh(Google.ProtocolBuffers.ByteString data) | ||
1514 | { | ||
1515 | return SetLMH(data, 24); | ||
1516 | } | ||
1517 | static ulong SetLMH(byte[] data, int offset) | ||
1518 | { | ||
1519 | ulong LowOrderBytes = 0; | ||
1520 | int shiftVal = 0; | ||
1521 | for (int i = 0; i < 8; ++i) | ||
1522 | { | ||
1523 | ulong temp = data[i]; | ||
1524 | LowOrderBytes |= (temp << shiftVal); | ||
1525 | shiftVal += 8; | ||
1526 | } | ||
1527 | return LowOrderBytes; | ||
1528 | } | ||
1529 | static ulong SetLow(byte[] data) | ||
1530 | { | ||
1531 | return SetLMH(data, 0); | ||
1532 | } | ||
1533 | static ulong SetLowMedium(byte[] data) | ||
1534 | { | ||
1535 | return SetLMH(data, 8); | ||
1536 | } | ||
1537 | static ulong SetMediumHigh(byte[] data) | ||
1538 | { | ||
1539 | return SetLMH(data, 16); | ||
1540 | } | ||
1541 | static ulong SetHigh(byte[] data) | ||
1542 | { | ||
1543 | return SetLMH(data, 24); | ||
1544 | } | ||
1545 | public bool SetSHA256(byte[] data) | ||
1546 | { | ||
1547 | if (data.Length == 32) | ||
1548 | { | ||
1549 | mLowOrderBytes = SetLow(data); | ||
1550 | mLowMediumOrderBytes = SetLowMedium(data); | ||
1551 | mMediumHighOrderBytes = SetMediumHigh(data); | ||
1552 | mHighOrderBytes = SetHigh(data); | ||
1553 | return true; | ||
1554 | } | ||
1555 | else | ||
1556 | { | ||
1557 | return false; | ||
1558 | } | ||
1559 | } | ||
1560 | public byte[] GetBinaryData() | ||
1561 | { | ||
1562 | byte[] data = new byte[32]; | ||
1563 | int shiftVal = 0; | ||
1564 | for (int i = 0; i < 8; ++i) | ||
1565 | { | ||
1566 | ulong temp = 0xff; | ||
1567 | temp = (mLowOrderBytes & (temp << shiftVal)); | ||
1568 | temp = (temp >> shiftVal); | ||
1569 | data[i] = (byte)temp; | ||
1570 | shiftVal += 8; | ||
1571 | } | ||
1572 | shiftVal = 0; | ||
1573 | for (int i = 8; i < 16; ++i) | ||
1574 | { | ||
1575 | ulong temp = 0xff; | ||
1576 | temp = (mLowMediumOrderBytes & (temp << shiftVal)); | ||
1577 | temp = (temp >> shiftVal); | ||
1578 | data[i] = (byte)temp; | ||
1579 | shiftVal += 8; | ||
1580 | } | ||
1581 | shiftVal = 0; | ||
1582 | for (int i = 16; i < 24; ++i) | ||
1583 | { | ||
1584 | ulong temp = 0xff; | ||
1585 | temp = (mMediumHighOrderBytes & (temp << shiftVal)); | ||
1586 | temp = (temp >> shiftVal); | ||
1587 | data[i] = (byte)temp; | ||
1588 | shiftVal += 8; | ||
1589 | } | ||
1590 | shiftVal = 0; | ||
1591 | for (int i = 24; i < 32; ++i) | ||
1592 | { | ||
1593 | ulong temp = 0xff; | ||
1594 | temp = (mHighOrderBytes & (temp << shiftVal)); | ||
1595 | temp = (temp >> shiftVal); | ||
1596 | data[i] = (byte)temp; | ||
1597 | shiftVal += 8; | ||
1598 | } | ||
1599 | return data; | ||
1600 | } | ||
1601 | |||
1602 | public static SHA256 Empty = new SHA256(new byte[32]); | ||
1603 | public SHA256(byte[] data) | ||
1604 | { | ||
1605 | if (data.Length != 32) | ||
1606 | { | ||
1607 | throw new System.ArgumentException("SHA256s must be provided 32 bytes"); | ||
1608 | } | ||
1609 | mLowOrderBytes = SetLow(data); | ||
1610 | mLowMediumOrderBytes = SetLowMedium(data); | ||
1611 | mMediumHighOrderBytes = SetMediumHigh(data); | ||
1612 | mHighOrderBytes = SetHigh(data); | ||
1613 | } | ||
1614 | public SHA256(Google.ProtocolBuffers.ByteString data) | ||
1615 | { | ||
1616 | if (data.Length != 32) | ||
1617 | { | ||
1618 | throw new System.ArgumentException("SHA256s must be provided 32 bytes"); | ||
1619 | } | ||
1620 | mLowOrderBytes = SetLow(data); | ||
1621 | mLowMediumOrderBytes = SetLowMedium(data); | ||
1622 | mMediumHighOrderBytes = SetMediumHigh(data); | ||
1623 | mHighOrderBytes = SetHigh(data); | ||
1624 | } | ||
1625 | |||
1626 | } | ||
1627 | |||
1628 | |||
1629 | |||
1630 | |||
1631 | public struct Time | ||
1632 | { | ||
1633 | ulong usec; | ||
1634 | public Time(ulong usec_since_epoch) | ||
1635 | { | ||
1636 | usec = usec_since_epoch; | ||
1637 | } | ||
1638 | public ulong toMicro() | ||
1639 | { | ||
1640 | return usec; | ||
1641 | } | ||
1642 | } | ||
1643 | public class Duration | ||
1644 | { | ||
1645 | long usec; | ||
1646 | public Duration(long time_since) | ||
1647 | { | ||
1648 | usec = time_since; | ||
1649 | } | ||
1650 | public long toMicro() | ||
1651 | { | ||
1652 | return usec; | ||
1653 | } | ||
1654 | } | ||
1655 | |||
1656 | class _PBJ | ||
1657 | { | ||
1658 | |||
1659 | public static bool ValidateBool(bool d) | ||
1660 | { | ||
1661 | return true; | ||
1662 | } | ||
1663 | public static bool ValidateDouble(double d) | ||
1664 | { | ||
1665 | return true; | ||
1666 | } | ||
1667 | public static bool ValidateFloat(float d) | ||
1668 | { | ||
1669 | return true; | ||
1670 | } | ||
1671 | public static bool ValidateUint64(ulong d) | ||
1672 | { | ||
1673 | return true; | ||
1674 | } | ||
1675 | public static bool ValidateUint32(uint d) | ||
1676 | { | ||
1677 | return true; | ||
1678 | } | ||
1679 | public static bool ValidateUint16(ushort d) | ||
1680 | { | ||
1681 | return true; | ||
1682 | } | ||
1683 | public static bool ValidateUint8(byte d) | ||
1684 | { | ||
1685 | return true; | ||
1686 | } | ||
1687 | public static bool ValidateInt64(long d) | ||
1688 | { | ||
1689 | return true; | ||
1690 | } | ||
1691 | public static bool ValidateInt32(int d) | ||
1692 | { | ||
1693 | return true; | ||
1694 | } | ||
1695 | public static bool ValidateInt16(short d) | ||
1696 | { | ||
1697 | return true; | ||
1698 | } | ||
1699 | public static bool ValidateInt8(sbyte d) | ||
1700 | { | ||
1701 | return true; | ||
1702 | } | ||
1703 | public static bool ValidateString<S>(S input) | ||
1704 | { | ||
1705 | return true; | ||
1706 | } | ||
1707 | public static bool ValidateBytes<B>(B input) | ||
1708 | { | ||
1709 | return true; | ||
1710 | } | ||
1711 | public static bool ValidateUuid(Google.ProtocolBuffers.ByteString input) | ||
1712 | { | ||
1713 | return input.Length == 16; | ||
1714 | } | ||
1715 | public static bool ValidateSha256(Google.ProtocolBuffers.ByteString input) | ||
1716 | { | ||
1717 | return input.Length == 32; | ||
1718 | } | ||
1719 | public static bool ValidateAngle(float input) | ||
1720 | { | ||
1721 | return input >= 0 && input <= 3.1415926536 * 2.0; | ||
1722 | } | ||
1723 | public static bool ValidateTime(ulong input) | ||
1724 | { | ||
1725 | return true; | ||
1726 | } | ||
1727 | public static bool ValidateDuration(long input) | ||
1728 | { | ||
1729 | return true; | ||
1730 | } | ||
1731 | public static bool ValidateFlags(ulong input, ulong verification) | ||
1732 | { | ||
1733 | return (input & verification) == input; | ||
1734 | } | ||
1735 | |||
1736 | |||
1737 | |||
1738 | |||
1739 | public static bool CastBool(bool d) | ||
1740 | { | ||
1741 | return d; | ||
1742 | } | ||
1743 | public static double CastDouble(double d) | ||
1744 | { | ||
1745 | return d; | ||
1746 | } | ||
1747 | public static float CastFloat(float d) | ||
1748 | { | ||
1749 | return d; | ||
1750 | } | ||
1751 | public static ulong CastUint64(ulong d) | ||
1752 | { | ||
1753 | return d; | ||
1754 | } | ||
1755 | public static uint CastUint32(uint d) | ||
1756 | { | ||
1757 | return d; | ||
1758 | } | ||
1759 | public static ushort CastUint16(ushort d) | ||
1760 | { | ||
1761 | return d; | ||
1762 | } | ||
1763 | public static byte CastUint8(byte d) | ||
1764 | { | ||
1765 | return d; | ||
1766 | } | ||
1767 | public static long CastInt64(long d) | ||
1768 | { | ||
1769 | return d; | ||
1770 | } | ||
1771 | public static int CastInt32(int d) | ||
1772 | { | ||
1773 | return d; | ||
1774 | } | ||
1775 | public static short CastInt16(short d) | ||
1776 | { | ||
1777 | return d; | ||
1778 | } | ||
1779 | public static sbyte CastInt8(sbyte d) | ||
1780 | { | ||
1781 | return d; | ||
1782 | } | ||
1783 | public static S CastString<S>(S input) | ||
1784 | { | ||
1785 | return input; | ||
1786 | } | ||
1787 | public static B CastBytes<B>(B input) | ||
1788 | { | ||
1789 | return input; | ||
1790 | } | ||
1791 | |||
1792 | |||
1793 | |||
1794 | public static bool CastBool() | ||
1795 | { | ||
1796 | return false; | ||
1797 | } | ||
1798 | public static double CastDouble() | ||
1799 | { | ||
1800 | return 0; | ||
1801 | } | ||
1802 | public static float CastFloat() | ||
1803 | { | ||
1804 | return 0; | ||
1805 | } | ||
1806 | public static ulong CastUint64() | ||
1807 | { | ||
1808 | return 0; | ||
1809 | } | ||
1810 | public static uint CastUint32() | ||
1811 | { | ||
1812 | return 0; | ||
1813 | } | ||
1814 | public static ushort CastUint16() | ||
1815 | { | ||
1816 | return 0; | ||
1817 | } | ||
1818 | public static byte CastUint8() | ||
1819 | { | ||
1820 | return 0; | ||
1821 | } | ||
1822 | public static long CastInt64() | ||
1823 | { | ||
1824 | return 0; | ||
1825 | } | ||
1826 | public static int CastInt32() | ||
1827 | { | ||
1828 | return 0; | ||
1829 | } | ||
1830 | public static short CastInt16() | ||
1831 | { | ||
1832 | return 0; | ||
1833 | } | ||
1834 | public static sbyte CastInt8() | ||
1835 | { | ||
1836 | return 0; | ||
1837 | } | ||
1838 | public static string CastString() | ||
1839 | { | ||
1840 | return ""; | ||
1841 | } | ||
1842 | public static Google.ProtocolBuffers.ByteString CastBytes() | ||
1843 | { | ||
1844 | return Google.ProtocolBuffers.ByteString.Empty; | ||
1845 | } | ||
1846 | |||
1847 | |||
1848 | public static ulong CastFlags(ulong data, ulong allFlagsOn) | ||
1849 | { | ||
1850 | return allFlagsOn & data; | ||
1851 | } | ||
1852 | public static ulong CastFlags(ulong allFlagsOn) | ||
1853 | { | ||
1854 | return 0; | ||
1855 | } | ||
1856 | |||
1857 | public static Vector3f CastNormal(float x, float y) | ||
1858 | { | ||
1859 | float neg = (x > 1.5f || y > 1.5f) ? -1.0f : 1.0f; | ||
1860 | if (x > 1.5) | ||
1861 | x -= 3; | ||
1862 | if (y > 1.5) | ||
1863 | y -= 3; | ||
1864 | return new Vector3f(x, y, neg - neg * (float)Math.Sqrt(x * x + y * y)); | ||
1865 | } | ||
1866 | public static Vector3f CastNormal() | ||
1867 | { | ||
1868 | return new Vector3f(0, 1, 0); | ||
1869 | } | ||
1870 | |||
1871 | |||
1872 | public static Vector2f CastVector2f(float x, float y) | ||
1873 | { | ||
1874 | return new Vector2f(x, y); | ||
1875 | } | ||
1876 | public static Vector2f CastVector2f() | ||
1877 | { | ||
1878 | return new Vector2f(0, 0); | ||
1879 | } | ||
1880 | |||
1881 | public static Vector3f CastVector3f(float x, float y, float z) | ||
1882 | { | ||
1883 | return new Vector3f(x, y, z); | ||
1884 | } | ||
1885 | public static Vector3f CastVector3f() | ||
1886 | { | ||
1887 | return new Vector3f(0, 0, 0); | ||
1888 | } | ||
1889 | |||
1890 | public static Vector4f CastVector4f(float x, float y, float z, float w) | ||
1891 | { | ||
1892 | return new Vector4f(x, y, z, w); | ||
1893 | } | ||
1894 | public static Vector4f CastVector4f() | ||
1895 | { | ||
1896 | return new Vector4f(0, 0, 0, 0); | ||
1897 | } | ||
1898 | public static Vector2d CastVector2d(double x, double y) | ||
1899 | { | ||
1900 | return new Vector2d(x, y); | ||
1901 | } | ||
1902 | public static Vector2d CastVector2d() | ||
1903 | { | ||
1904 | return new Vector2d(0, 0); | ||
1905 | } | ||
1906 | |||
1907 | public static Vector3d CastVector3d(double x, double y, double z) | ||
1908 | { | ||
1909 | return new Vector3d(x, y, z); | ||
1910 | } | ||
1911 | public static Vector3d CastVector3d() | ||
1912 | { | ||
1913 | return new Vector3d(0, 0, 0); | ||
1914 | } | ||
1915 | |||
1916 | public static Vector4d CastVector4d(double x, double y, double z, double w) | ||
1917 | { | ||
1918 | return new Vector4d(x, y, z, w); | ||
1919 | } | ||
1920 | public static Vector4d CastVector4d() | ||
1921 | { | ||
1922 | return new Vector4d(0, 0, 0, 0); | ||
1923 | } | ||
1924 | |||
1925 | public static BoundingSphere3f CastBoundingsphere3f(float x, float y, float z, float r) | ||
1926 | { | ||
1927 | return new BoundingSphere3f(new Vector3f(x, y, z), r); | ||
1928 | } | ||
1929 | public static BoundingSphere3d CastBoundingsphere3d(double x, double y, double z, double r) | ||
1930 | { | ||
1931 | return new BoundingSphere3d(new Vector3d(x, y, z), (float)r); | ||
1932 | } | ||
1933 | |||
1934 | public static BoundingSphere3f CastBoundingsphere3f() | ||
1935 | { | ||
1936 | return new BoundingSphere3f(new Vector3f(0, 0, 0), 0); | ||
1937 | } | ||
1938 | public static BoundingSphere3d CastBoundingsphere3d() | ||
1939 | { | ||
1940 | return new BoundingSphere3d(new Vector3d(0, 0, 0), (float)0); | ||
1941 | } | ||
1942 | |||
1943 | |||
1944 | public static BoundingBox3f3f CastBoundingbox3f3f(float x, float y, float z, float dx, float dy, float dz) | ||
1945 | { | ||
1946 | return new BoundingBox3f3f(x, y, z, dx, dy, dz); | ||
1947 | } | ||
1948 | public static BoundingBox3d3f CastBoundingbox3d3f(double x, double y, double z, double dx, double dy, double dz) | ||
1949 | { | ||
1950 | return new BoundingBox3d3f(x, y, z, (float)dx, (float)dy, (float)dz); | ||
1951 | } | ||
1952 | |||
1953 | public static BoundingBox3f3f CastBoundingbox3f3f() | ||
1954 | { | ||
1955 | return new BoundingBox3f3f(new Vector3f(0, 0, 0), new Vector3f(0, 0, 0)); | ||
1956 | } | ||
1957 | public static BoundingBox3d3f CastBoundingbox3d3f() | ||
1958 | { | ||
1959 | return new BoundingBox3d3f(0, 0, 0, 0, 0, 0); | ||
1960 | } | ||
1961 | |||
1962 | |||
1963 | |||
1964 | public static Quaternion CastQuaternion(float x, float y, float z) | ||
1965 | { | ||
1966 | float neg = (x > 1.5 || y > 1.5 || z > 1.5) ? -1.0f : 1.0f; | ||
1967 | if (x > 1.5) | ||
1968 | x -= 3.0f; | ||
1969 | if (y > 1.5) | ||
1970 | y -= 3.0f; | ||
1971 | if (z > 1.5) | ||
1972 | z -= 3.0f; | ||
1973 | return new Quaternion(neg - neg * (float)Math.Sqrt(x * x + y * y + z * z), x, y, z); | ||
1974 | } | ||
1975 | public static Quaternion CastQuaternion() | ||
1976 | { | ||
1977 | return new Quaternion(1, 0, 0, 0); | ||
1978 | } | ||
1979 | |||
1980 | public static UUID CastUuid(Google.ProtocolBuffers.ByteString input) | ||
1981 | { | ||
1982 | return new UUID(input); | ||
1983 | } | ||
1984 | public static SHA256 CastSha256(Google.ProtocolBuffers.ByteString input) | ||
1985 | { | ||
1986 | return new SHA256(input); | ||
1987 | } | ||
1988 | public static SHA256 CastSha256() | ||
1989 | { | ||
1990 | return SHA256.Empty; | ||
1991 | } | ||
1992 | public static UUID CastUuid() | ||
1993 | { | ||
1994 | return UUID.Empty; | ||
1995 | } | ||
1996 | |||
1997 | public static float CastAngle(float d) | ||
1998 | { | ||
1999 | return d; | ||
2000 | } | ||
2001 | public static float CastAngle() | ||
2002 | { | ||
2003 | return 0; | ||
2004 | } | ||
2005 | |||
2006 | public static Time CastTime(ulong t) | ||
2007 | { | ||
2008 | return new Time(t); | ||
2009 | } | ||
2010 | public static Time CastTime() | ||
2011 | { | ||
2012 | return new Time(0); | ||
2013 | } | ||
2014 | public static Duration CastDuration(long t) | ||
2015 | { | ||
2016 | return new Duration(t); | ||
2017 | } | ||
2018 | public static Duration CastDuration() | ||
2019 | { | ||
2020 | return new Duration(0); | ||
2021 | } | ||
2022 | |||
2023 | public static T Construct<T>(T retval) | ||
2024 | { | ||
2025 | return retval; | ||
2026 | } | ||
2027 | public static long Construct(Duration d) | ||
2028 | { | ||
2029 | return d.toMicro(); | ||
2030 | } | ||
2031 | public static ulong Construct(Time t) | ||
2032 | { | ||
2033 | return t.toMicro(); | ||
2034 | } | ||
2035 | public static Google.ProtocolBuffers.ByteString Construct(UUID u) | ||
2036 | { | ||
2037 | byte[] data = u.GetUUID(); | ||
2038 | Google.ProtocolBuffers.ByteString retval = Google.ProtocolBuffers.ByteString.CopyFrom(data, 0, 16); | ||
2039 | return retval; | ||
2040 | } | ||
2041 | public static Google.ProtocolBuffers.ByteString Construct(SHA256 u) | ||
2042 | { | ||
2043 | byte[] data = u.GetBinaryData(); | ||
2044 | Google.ProtocolBuffers.ByteString retval = Google.ProtocolBuffers.ByteString.CopyFrom(data, 0, 16); | ||
2045 | return retval; | ||
2046 | } | ||
2047 | public static float[] ConstructNormal(Vector3f d) | ||
2048 | { | ||
2049 | return new float[] { d.x + (d.z < 0 ? 3.0f : 0.0f), d.y }; | ||
2050 | } | ||
2051 | public static float[] ConstructQuaternion(Quaternion d) | ||
2052 | { | ||
2053 | return new float[] { d.x + (d.w < 0 ? 3.0f : 0.0f), d.y, d.z }; | ||
2054 | } | ||
2055 | |||
2056 | public static float[] ConstructVector2f(Vector2f d) | ||
2057 | { | ||
2058 | return new float[] { d.x, d.y }; | ||
2059 | } | ||
2060 | public static double[] ConstructVector2d(Vector2d d) | ||
2061 | { | ||
2062 | return new double[] { d.x, d.y }; | ||
2063 | } | ||
2064 | |||
2065 | public static float[] ConstructVector3f(Vector3f d) | ||
2066 | { | ||
2067 | return new float[] { d.x, d.y, d.z }; | ||
2068 | } | ||
2069 | public static double[] ConstructVector3d(Vector3d d) | ||
2070 | { | ||
2071 | return new double[] { d.x, d.y, d.z }; | ||
2072 | } | ||
2073 | public static float[] ConstructVector4f(Vector4f d) | ||
2074 | { | ||
2075 | return new float[] { d.x, d.y, d.z, d.w }; | ||
2076 | } | ||
2077 | public static double[] ConstructVector4d(Vector4d d) | ||
2078 | { | ||
2079 | return new double[] { d.x, d.y, d.z, d.w }; | ||
2080 | } | ||
2081 | |||
2082 | |||
2083 | public static float[] ConstructBoundingsphere3f(BoundingSphere3f d) | ||
2084 | { | ||
2085 | return new float[] { d.Center.x, d.Center.y, d.Center.z, d.Radius }; | ||
2086 | } | ||
2087 | public static double[] ConstructBoundingsphere3d(BoundingSphere3d d) | ||
2088 | { | ||
2089 | return new double[] { d.Center.x, d.Center.y, d.Center.z, d.Radius }; | ||
2090 | } | ||
2091 | |||
2092 | public static float[] ConstructBoundingbox3f3f(BoundingBox3f3f d) | ||
2093 | { | ||
2094 | return new float[] { d.Min.x, d.Min.y, d.Min.z, d.Diag.x, d.Diag.y, d.Diag.z }; | ||
2095 | } | ||
2096 | public static double[] ConstructBoundingbox3d3f(BoundingBox3d3f d) | ||
2097 | { | ||
2098 | return new double[] { d.Min.x, d.Min.y, d.Min.z, d.Diag.x, d.Diag.y, d.Diag.z }; | ||
2099 | } | ||
2100 | |||
2101 | |||
2102 | } | ||
2103 | |||
2104 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Persistence.cs b/OpenSim/Client/Sirikata/Protocol/Persistence.cs deleted file mode 100644 index d8f8d33..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Persistence.cs +++ /dev/null | |||
@@ -1,3299 +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.Persistence.Protocol._PBJ_Internal { | ||
8 | |||
9 | public static partial class Persistence { | ||
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_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor; | ||
17 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__FieldAccessorTable; | ||
18 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor; | ||
19 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__FieldAccessorTable; | ||
20 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor; | ||
21 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__FieldAccessorTable; | ||
22 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor; | ||
23 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement, global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__FieldAccessorTable; | ||
24 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor; | ||
25 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__FieldAccessorTable; | ||
26 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor; | ||
27 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__FieldAccessorTable; | ||
28 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor; | ||
29 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__FieldAccessorTable; | ||
30 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor; | ||
31 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__FieldAccessorTable; | ||
32 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor; | ||
33 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction, global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__FieldAccessorTable; | ||
34 | internal static pbd::MessageDescriptor internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor; | ||
35 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.Response, global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Builder> internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__FieldAccessorTable; | ||
36 | #endregion | ||
37 | #region Descriptor | ||
38 | public static pbd::FileDescriptor Descriptor { | ||
39 | get { return descriptor; } | ||
40 | } | ||
41 | private static pbd::FileDescriptor descriptor; | ||
42 | |||
43 | static Persistence() { | ||
44 | byte[] descriptorData = global::System.Convert.FromBase64String( | ||
45 | "ChFQZXJzaXN0ZW5jZS5wcm90bxIrU2lyaWthdGEuUGVyc2lzdGVuY2UuUHJv" + | ||
46 | "dG9jb2wuX1BCSl9JbnRlcm5hbCJHCgpTdG9yYWdlS2V5EhMKC29iamVjdF91" + | ||
47 | "dWlkGAkgASgMEhAKCGZpZWxkX2lkGAogASgEEhIKCmZpZWxkX25hbWUYCyAB" + | ||
48 | "KAkiHAoMU3RvcmFnZVZhbHVlEgwKBGRhdGEYDCABKAwi/gEKDlN0b3JhZ2VF" + | ||
49 | "bGVtZW50EhMKC29iamVjdF91dWlkGAkgASgMEhAKCGZpZWxkX2lkGAogASgE" + | ||
50 | "EhIKCmZpZWxkX25hbWUYCyABKAkSDAoEZGF0YRgMIAEoDBINCgVpbmRleBgN" + | ||
51 | "IAEoBRJfCg1yZXR1cm5fc3RhdHVzGA8gASgOMkguU2lyaWthdGEuUGVyc2lz" + | ||
52 | "dGVuY2UuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5TdG9yYWdlRWxlbWVudC5S" + | ||
53 | "ZXR1cm5TdGF0dXMiMwoMUmV0dXJuU3RhdHVzEg8KC0tFWV9NSVNTSU5HEAQS" + | ||
54 | "EgoOSU5URVJOQUxfRVJST1IQBiLaAQoOQ29tcGFyZUVsZW1lbnQSEwoLb2Jq" + | ||
55 | "ZWN0X3V1aWQYCSABKAwSEAoIZmllbGRfaWQYCiABKAQSEgoKZmllbGRfbmFt" + | ||
56 | "ZRgLIAEoCRIMCgRkYXRhGAwgASgMEloKCmNvbXBhcmF0b3IYDiABKA4yRi5T" + | ||
57 | "aXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLkNv" + | ||
58 | "bXBhcmVFbGVtZW50LkNPTVBBUkFUT1IiIwoKQ09NUEFSQVRPUhIJCgVFUVVB" + | ||
59 | "TBAAEgoKBk5FUVVBTBABIlgKClN0b3JhZ2VTZXQSSgoFcmVhZHMYCSADKAsy" + | ||
60 | "Oy5TaXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFs" + | ||
61 | "LlN0b3JhZ2VFbGVtZW50IlUKB1JlYWRTZXQSSgoFcmVhZHMYCSADKAsyOy5T" + | ||
62 | "aXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLlN0" + | ||
63 | "b3JhZ2VFbGVtZW50IlcKCFdyaXRlU2V0EksKBndyaXRlcxgKIAMoCzI7LlNp" + | ||
64 | "cmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuU3Rv" + | ||
65 | "cmFnZUVsZW1lbnQi5gEKDFJlYWRXcml0ZVNldBJKCgVyZWFkcxgJIAMoCzI7" + | ||
66 | "LlNpcmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJuYWwu" + | ||
67 | "U3RvcmFnZUVsZW1lbnQSSwoGd3JpdGVzGAogAygLMjsuU2lyaWthdGEuUGVy" + | ||
68 | "c2lzdGVuY2UuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5TdG9yYWdlRWxlbWVu" + | ||
69 | "dBIPCgdvcHRpb25zGA4gASgEIiwKE1JlYWRXcml0ZVNldE9wdGlvbnMSFQoR" + | ||
70 | "UkVUVVJOX1JFQURfTkFNRVMQASK3AgoPTWluaXRyYW5zYWN0aW9uEkoKBXJl" + | ||
71 | "YWRzGAkgAygLMjsuU2lyaWthdGEuUGVyc2lzdGVuY2UuUHJvdG9jb2wuX1BC" + | ||
72 | "Sl9JbnRlcm5hbC5TdG9yYWdlRWxlbWVudBJLCgZ3cml0ZXMYCiADKAsyOy5T" + | ||
73 | "aXJpa2F0YS5QZXJzaXN0ZW5jZS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLlN0" + | ||
74 | "b3JhZ2VFbGVtZW50Ek0KCGNvbXBhcmVzGAsgAygLMjsuU2lyaWthdGEuUGVy" + | ||
75 | "c2lzdGVuY2UuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5Db21wYXJlRWxlbWVu" + | ||
76 | "dBIPCgdvcHRpb25zGA4gASgEIisKElRyYW5zYWN0aW9uT3B0aW9ucxIVChFS" + | ||
77 | "RVRVUk5fUkVBRF9OQU1FUxABIp8CCghSZXNwb25zZRJKCgVyZWFkcxgJIAMo" + | ||
78 | "CzI7LlNpcmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJu" + | ||
79 | "YWwuU3RvcmFnZUVsZW1lbnQSWQoNcmV0dXJuX3N0YXR1cxgPIAEoDjJCLlNp" + | ||
80 | "cmlrYXRhLlBlcnNpc3RlbmNlLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuUmVz" + | ||
81 | "cG9uc2UuUmV0dXJuU3RhdHVzImwKDFJldHVyblN0YXR1cxILCgdTVUNDRVNT" + | ||
82 | "EAASEwoPREFUQUJBU0VfTE9DS0VEEAMSDwoLS0VZX01JU1NJTkcQBBIVChFD" + | ||
83 | "T01QQVJJU09OX0ZBSUxFRBAFEhIKDklOVEVSTkFMX0VSUk9SEAY="); | ||
84 | pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | ||
85 | descriptor = root; | ||
86 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor = Descriptor.MessageTypes[0]; | ||
87 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__FieldAccessorTable = | ||
88 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor, | ||
89 | new string[] { "ObjectUuid", "FieldId", "FieldName", }); | ||
90 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor = Descriptor.MessageTypes[1]; | ||
91 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__FieldAccessorTable = | ||
92 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor, | ||
93 | new string[] { "Data", }); | ||
94 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor = Descriptor.MessageTypes[2]; | ||
95 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__FieldAccessorTable = | ||
96 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor, | ||
97 | new string[] { "ObjectUuid", "FieldId", "FieldName", "Data", "Index", "ReturnStatus", }); | ||
98 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor = Descriptor.MessageTypes[3]; | ||
99 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__FieldAccessorTable = | ||
100 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement, global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor, | ||
101 | new string[] { "ObjectUuid", "FieldId", "FieldName", "Data", "Comparator", }); | ||
102 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor = Descriptor.MessageTypes[4]; | ||
103 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__FieldAccessorTable = | ||
104 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor, | ||
105 | new string[] { "Reads", }); | ||
106 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor = Descriptor.MessageTypes[5]; | ||
107 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__FieldAccessorTable = | ||
108 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor, | ||
109 | new string[] { "Reads", }); | ||
110 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor = Descriptor.MessageTypes[6]; | ||
111 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__FieldAccessorTable = | ||
112 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor, | ||
113 | new string[] { "Writes", }); | ||
114 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor = Descriptor.MessageTypes[7]; | ||
115 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__FieldAccessorTable = | ||
116 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet, global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor, | ||
117 | new string[] { "Reads", "Writes", "Options", }); | ||
118 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor = Descriptor.MessageTypes[8]; | ||
119 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__FieldAccessorTable = | ||
120 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction, global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor, | ||
121 | new string[] { "Reads", "Writes", "Compares", "Options", }); | ||
122 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor = Descriptor.MessageTypes[9]; | ||
123 | internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__FieldAccessorTable = | ||
124 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Persistence.Protocol._PBJ_Internal.Response, global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Builder>(internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor, | ||
125 | new string[] { "Reads", "ReturnStatus", }); | ||
126 | return null; | ||
127 | }; | ||
128 | pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | ||
129 | new pbd::FileDescriptor[] { | ||
130 | }, assigner); | ||
131 | } | ||
132 | #endregion | ||
133 | |||
134 | } | ||
135 | #region Messages | ||
136 | public sealed partial class StorageKey : pb::GeneratedMessage<StorageKey, StorageKey.Builder> { | ||
137 | private static readonly StorageKey defaultInstance = new Builder().BuildPartial(); | ||
138 | public static StorageKey DefaultInstance { | ||
139 | get { return defaultInstance; } | ||
140 | } | ||
141 | |||
142 | public override StorageKey DefaultInstanceForType { | ||
143 | get { return defaultInstance; } | ||
144 | } | ||
145 | |||
146 | protected override StorageKey ThisMessage { | ||
147 | get { return this; } | ||
148 | } | ||
149 | |||
150 | public static pbd::MessageDescriptor Descriptor { | ||
151 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__Descriptor; } | ||
152 | } | ||
153 | |||
154 | protected override pb::FieldAccess.FieldAccessorTable<StorageKey, StorageKey.Builder> InternalFieldAccessors { | ||
155 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageKey__FieldAccessorTable; } | ||
156 | } | ||
157 | |||
158 | public const int ObjectUuidFieldNumber = 9; | ||
159 | private bool hasObjectUuid; | ||
160 | private pb::ByteString objectUuid_ = pb::ByteString.Empty; | ||
161 | public bool HasObjectUuid { | ||
162 | get { return hasObjectUuid; } | ||
163 | } | ||
164 | public pb::ByteString ObjectUuid { | ||
165 | get { return objectUuid_; } | ||
166 | } | ||
167 | |||
168 | public const int FieldIdFieldNumber = 10; | ||
169 | private bool hasFieldId; | ||
170 | private ulong fieldId_ = 0UL; | ||
171 | public bool HasFieldId { | ||
172 | get { return hasFieldId; } | ||
173 | } | ||
174 | [global::System.CLSCompliant(false)] | ||
175 | public ulong FieldId { | ||
176 | get { return fieldId_; } | ||
177 | } | ||
178 | |||
179 | public const int FieldNameFieldNumber = 11; | ||
180 | private bool hasFieldName; | ||
181 | private string fieldName_ = ""; | ||
182 | public bool HasFieldName { | ||
183 | get { return hasFieldName; } | ||
184 | } | ||
185 | public string FieldName { | ||
186 | get { return fieldName_; } | ||
187 | } | ||
188 | |||
189 | public override bool IsInitialized { | ||
190 | get { | ||
191 | return true; | ||
192 | } | ||
193 | } | ||
194 | |||
195 | public override void WriteTo(pb::CodedOutputStream output) { | ||
196 | if (HasObjectUuid) { | ||
197 | output.WriteBytes(9, ObjectUuid); | ||
198 | } | ||
199 | if (HasFieldId) { | ||
200 | output.WriteUInt64(10, FieldId); | ||
201 | } | ||
202 | if (HasFieldName) { | ||
203 | output.WriteString(11, FieldName); | ||
204 | } | ||
205 | UnknownFields.WriteTo(output); | ||
206 | } | ||
207 | |||
208 | private int memoizedSerializedSize = -1; | ||
209 | public override int SerializedSize { | ||
210 | get { | ||
211 | int size = memoizedSerializedSize; | ||
212 | if (size != -1) return size; | ||
213 | |||
214 | size = 0; | ||
215 | if (HasObjectUuid) { | ||
216 | size += pb::CodedOutputStream.ComputeBytesSize(9, ObjectUuid); | ||
217 | } | ||
218 | if (HasFieldId) { | ||
219 | size += pb::CodedOutputStream.ComputeUInt64Size(10, FieldId); | ||
220 | } | ||
221 | if (HasFieldName) { | ||
222 | size += pb::CodedOutputStream.ComputeStringSize(11, FieldName); | ||
223 | } | ||
224 | size += UnknownFields.SerializedSize; | ||
225 | memoizedSerializedSize = size; | ||
226 | return size; | ||
227 | } | ||
228 | } | ||
229 | |||
230 | public static StorageKey ParseFrom(pb::ByteString data) { | ||
231 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
232 | } | ||
233 | public static StorageKey ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
234 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
235 | } | ||
236 | public static StorageKey ParseFrom(byte[] data) { | ||
237 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
238 | } | ||
239 | public static StorageKey ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
240 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
241 | } | ||
242 | public static StorageKey ParseFrom(global::System.IO.Stream input) { | ||
243 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
244 | } | ||
245 | public static StorageKey ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
246 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
247 | } | ||
248 | public static StorageKey ParseDelimitedFrom(global::System.IO.Stream input) { | ||
249 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
250 | } | ||
251 | public static StorageKey ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
252 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
253 | } | ||
254 | public static StorageKey ParseFrom(pb::CodedInputStream input) { | ||
255 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
256 | } | ||
257 | public static StorageKey ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
258 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
259 | } | ||
260 | public static Builder CreateBuilder() { return new Builder(); } | ||
261 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
262 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
263 | public static Builder CreateBuilder(StorageKey prototype) { | ||
264 | return (Builder) new Builder().MergeFrom(prototype); | ||
265 | } | ||
266 | |||
267 | public sealed partial class Builder : pb::GeneratedBuilder<StorageKey, Builder> { | ||
268 | protected override Builder ThisBuilder { | ||
269 | get { return this; } | ||
270 | } | ||
271 | public Builder() {} | ||
272 | |||
273 | StorageKey result = new StorageKey(); | ||
274 | |||
275 | protected override StorageKey MessageBeingBuilt { | ||
276 | get { return result; } | ||
277 | } | ||
278 | |||
279 | public override Builder Clear() { | ||
280 | result = new StorageKey(); | ||
281 | return this; | ||
282 | } | ||
283 | |||
284 | public override Builder Clone() { | ||
285 | return new Builder().MergeFrom(result); | ||
286 | } | ||
287 | |||
288 | public override pbd::MessageDescriptor DescriptorForType { | ||
289 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.Descriptor; } | ||
290 | } | ||
291 | |||
292 | public override StorageKey DefaultInstanceForType { | ||
293 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.DefaultInstance; } | ||
294 | } | ||
295 | |||
296 | public override StorageKey BuildPartial() { | ||
297 | if (result == null) { | ||
298 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
299 | } | ||
300 | StorageKey returnMe = result; | ||
301 | result = null; | ||
302 | return returnMe; | ||
303 | } | ||
304 | |||
305 | public override Builder MergeFrom(pb::IMessage other) { | ||
306 | if (other is StorageKey) { | ||
307 | return MergeFrom((StorageKey) other); | ||
308 | } else { | ||
309 | base.MergeFrom(other); | ||
310 | return this; | ||
311 | } | ||
312 | } | ||
313 | |||
314 | public override Builder MergeFrom(StorageKey other) { | ||
315 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageKey.DefaultInstance) return this; | ||
316 | if (other.HasObjectUuid) { | ||
317 | ObjectUuid = other.ObjectUuid; | ||
318 | } | ||
319 | if (other.HasFieldId) { | ||
320 | FieldId = other.FieldId; | ||
321 | } | ||
322 | if (other.HasFieldName) { | ||
323 | FieldName = other.FieldName; | ||
324 | } | ||
325 | this.MergeUnknownFields(other.UnknownFields); | ||
326 | return this; | ||
327 | } | ||
328 | |||
329 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
330 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
331 | } | ||
332 | |||
333 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
334 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
335 | while (true) { | ||
336 | uint tag = input.ReadTag(); | ||
337 | switch (tag) { | ||
338 | case 0: { | ||
339 | if (unknownFields != null) { | ||
340 | this.UnknownFields = unknownFields.Build(); | ||
341 | } | ||
342 | return this; | ||
343 | } | ||
344 | default: { | ||
345 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
346 | if (unknownFields != null) { | ||
347 | this.UnknownFields = unknownFields.Build(); | ||
348 | } | ||
349 | return this; | ||
350 | } | ||
351 | if (unknownFields == null) { | ||
352 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
353 | } | ||
354 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
355 | break; | ||
356 | } | ||
357 | case 74: { | ||
358 | ObjectUuid = input.ReadBytes(); | ||
359 | break; | ||
360 | } | ||
361 | case 80: { | ||
362 | FieldId = input.ReadUInt64(); | ||
363 | break; | ||
364 | } | ||
365 | case 90: { | ||
366 | FieldName = input.ReadString(); | ||
367 | break; | ||
368 | } | ||
369 | } | ||
370 | } | ||
371 | } | ||
372 | |||
373 | |||
374 | public bool HasObjectUuid { | ||
375 | get { return result.HasObjectUuid; } | ||
376 | } | ||
377 | public pb::ByteString ObjectUuid { | ||
378 | get { return result.ObjectUuid; } | ||
379 | set { SetObjectUuid(value); } | ||
380 | } | ||
381 | public Builder SetObjectUuid(pb::ByteString value) { | ||
382 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
383 | result.hasObjectUuid = true; | ||
384 | result.objectUuid_ = value; | ||
385 | return this; | ||
386 | } | ||
387 | public Builder ClearObjectUuid() { | ||
388 | result.hasObjectUuid = false; | ||
389 | result.objectUuid_ = pb::ByteString.Empty; | ||
390 | return this; | ||
391 | } | ||
392 | |||
393 | public bool HasFieldId { | ||
394 | get { return result.HasFieldId; } | ||
395 | } | ||
396 | [global::System.CLSCompliant(false)] | ||
397 | public ulong FieldId { | ||
398 | get { return result.FieldId; } | ||
399 | set { SetFieldId(value); } | ||
400 | } | ||
401 | [global::System.CLSCompliant(false)] | ||
402 | public Builder SetFieldId(ulong value) { | ||
403 | result.hasFieldId = true; | ||
404 | result.fieldId_ = value; | ||
405 | return this; | ||
406 | } | ||
407 | public Builder ClearFieldId() { | ||
408 | result.hasFieldId = false; | ||
409 | result.fieldId_ = 0UL; | ||
410 | return this; | ||
411 | } | ||
412 | |||
413 | public bool HasFieldName { | ||
414 | get { return result.HasFieldName; } | ||
415 | } | ||
416 | public string FieldName { | ||
417 | get { return result.FieldName; } | ||
418 | set { SetFieldName(value); } | ||
419 | } | ||
420 | public Builder SetFieldName(string value) { | ||
421 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
422 | result.hasFieldName = true; | ||
423 | result.fieldName_ = value; | ||
424 | return this; | ||
425 | } | ||
426 | public Builder ClearFieldName() { | ||
427 | result.hasFieldName = false; | ||
428 | result.fieldName_ = ""; | ||
429 | return this; | ||
430 | } | ||
431 | } | ||
432 | static StorageKey() { | ||
433 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
434 | } | ||
435 | } | ||
436 | |||
437 | public sealed partial class StorageValue : pb::GeneratedMessage<StorageValue, StorageValue.Builder> { | ||
438 | private static readonly StorageValue defaultInstance = new Builder().BuildPartial(); | ||
439 | public static StorageValue DefaultInstance { | ||
440 | get { return defaultInstance; } | ||
441 | } | ||
442 | |||
443 | public override StorageValue DefaultInstanceForType { | ||
444 | get { return defaultInstance; } | ||
445 | } | ||
446 | |||
447 | protected override StorageValue ThisMessage { | ||
448 | get { return this; } | ||
449 | } | ||
450 | |||
451 | public static pbd::MessageDescriptor Descriptor { | ||
452 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__Descriptor; } | ||
453 | } | ||
454 | |||
455 | protected override pb::FieldAccess.FieldAccessorTable<StorageValue, StorageValue.Builder> InternalFieldAccessors { | ||
456 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageValue__FieldAccessorTable; } | ||
457 | } | ||
458 | |||
459 | public const int DataFieldNumber = 12; | ||
460 | private bool hasData; | ||
461 | private pb::ByteString data_ = pb::ByteString.Empty; | ||
462 | public bool HasData { | ||
463 | get { return hasData; } | ||
464 | } | ||
465 | public pb::ByteString Data { | ||
466 | get { return data_; } | ||
467 | } | ||
468 | |||
469 | public override bool IsInitialized { | ||
470 | get { | ||
471 | return true; | ||
472 | } | ||
473 | } | ||
474 | |||
475 | public override void WriteTo(pb::CodedOutputStream output) { | ||
476 | if (HasData) { | ||
477 | output.WriteBytes(12, Data); | ||
478 | } | ||
479 | UnknownFields.WriteTo(output); | ||
480 | } | ||
481 | |||
482 | private int memoizedSerializedSize = -1; | ||
483 | public override int SerializedSize { | ||
484 | get { | ||
485 | int size = memoizedSerializedSize; | ||
486 | if (size != -1) return size; | ||
487 | |||
488 | size = 0; | ||
489 | if (HasData) { | ||
490 | size += pb::CodedOutputStream.ComputeBytesSize(12, Data); | ||
491 | } | ||
492 | size += UnknownFields.SerializedSize; | ||
493 | memoizedSerializedSize = size; | ||
494 | return size; | ||
495 | } | ||
496 | } | ||
497 | |||
498 | public static StorageValue ParseFrom(pb::ByteString data) { | ||
499 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
500 | } | ||
501 | public static StorageValue ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
502 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
503 | } | ||
504 | public static StorageValue ParseFrom(byte[] data) { | ||
505 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
506 | } | ||
507 | public static StorageValue ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
508 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
509 | } | ||
510 | public static StorageValue ParseFrom(global::System.IO.Stream input) { | ||
511 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
512 | } | ||
513 | public static StorageValue ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
514 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
515 | } | ||
516 | public static StorageValue ParseDelimitedFrom(global::System.IO.Stream input) { | ||
517 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
518 | } | ||
519 | public static StorageValue ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
520 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
521 | } | ||
522 | public static StorageValue ParseFrom(pb::CodedInputStream input) { | ||
523 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
524 | } | ||
525 | public static StorageValue ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
526 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
527 | } | ||
528 | public static Builder CreateBuilder() { return new Builder(); } | ||
529 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
530 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
531 | public static Builder CreateBuilder(StorageValue prototype) { | ||
532 | return (Builder) new Builder().MergeFrom(prototype); | ||
533 | } | ||
534 | |||
535 | public sealed partial class Builder : pb::GeneratedBuilder<StorageValue, Builder> { | ||
536 | protected override Builder ThisBuilder { | ||
537 | get { return this; } | ||
538 | } | ||
539 | public Builder() {} | ||
540 | |||
541 | StorageValue result = new StorageValue(); | ||
542 | |||
543 | protected override StorageValue MessageBeingBuilt { | ||
544 | get { return result; } | ||
545 | } | ||
546 | |||
547 | public override Builder Clear() { | ||
548 | result = new StorageValue(); | ||
549 | return this; | ||
550 | } | ||
551 | |||
552 | public override Builder Clone() { | ||
553 | return new Builder().MergeFrom(result); | ||
554 | } | ||
555 | |||
556 | public override pbd::MessageDescriptor DescriptorForType { | ||
557 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.Descriptor; } | ||
558 | } | ||
559 | |||
560 | public override StorageValue DefaultInstanceForType { | ||
561 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.DefaultInstance; } | ||
562 | } | ||
563 | |||
564 | public override StorageValue BuildPartial() { | ||
565 | if (result == null) { | ||
566 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
567 | } | ||
568 | StorageValue returnMe = result; | ||
569 | result = null; | ||
570 | return returnMe; | ||
571 | } | ||
572 | |||
573 | public override Builder MergeFrom(pb::IMessage other) { | ||
574 | if (other is StorageValue) { | ||
575 | return MergeFrom((StorageValue) other); | ||
576 | } else { | ||
577 | base.MergeFrom(other); | ||
578 | return this; | ||
579 | } | ||
580 | } | ||
581 | |||
582 | public override Builder MergeFrom(StorageValue other) { | ||
583 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageValue.DefaultInstance) return this; | ||
584 | if (other.HasData) { | ||
585 | Data = other.Data; | ||
586 | } | ||
587 | this.MergeUnknownFields(other.UnknownFields); | ||
588 | return this; | ||
589 | } | ||
590 | |||
591 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
592 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
593 | } | ||
594 | |||
595 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
596 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
597 | while (true) { | ||
598 | uint tag = input.ReadTag(); | ||
599 | switch (tag) { | ||
600 | case 0: { | ||
601 | if (unknownFields != null) { | ||
602 | this.UnknownFields = unknownFields.Build(); | ||
603 | } | ||
604 | return this; | ||
605 | } | ||
606 | default: { | ||
607 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
608 | if (unknownFields != null) { | ||
609 | this.UnknownFields = unknownFields.Build(); | ||
610 | } | ||
611 | return this; | ||
612 | } | ||
613 | if (unknownFields == null) { | ||
614 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
615 | } | ||
616 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
617 | break; | ||
618 | } | ||
619 | case 98: { | ||
620 | Data = input.ReadBytes(); | ||
621 | break; | ||
622 | } | ||
623 | } | ||
624 | } | ||
625 | } | ||
626 | |||
627 | |||
628 | public bool HasData { | ||
629 | get { return result.HasData; } | ||
630 | } | ||
631 | public pb::ByteString Data { | ||
632 | get { return result.Data; } | ||
633 | set { SetData(value); } | ||
634 | } | ||
635 | public Builder SetData(pb::ByteString value) { | ||
636 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
637 | result.hasData = true; | ||
638 | result.data_ = value; | ||
639 | return this; | ||
640 | } | ||
641 | public Builder ClearData() { | ||
642 | result.hasData = false; | ||
643 | result.data_ = pb::ByteString.Empty; | ||
644 | return this; | ||
645 | } | ||
646 | } | ||
647 | static StorageValue() { | ||
648 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
649 | } | ||
650 | } | ||
651 | |||
652 | public sealed partial class StorageElement : pb::GeneratedMessage<StorageElement, StorageElement.Builder> { | ||
653 | private static readonly StorageElement defaultInstance = new Builder().BuildPartial(); | ||
654 | public static StorageElement DefaultInstance { | ||
655 | get { return defaultInstance; } | ||
656 | } | ||
657 | |||
658 | public override StorageElement DefaultInstanceForType { | ||
659 | get { return defaultInstance; } | ||
660 | } | ||
661 | |||
662 | protected override StorageElement ThisMessage { | ||
663 | get { return this; } | ||
664 | } | ||
665 | |||
666 | public static pbd::MessageDescriptor Descriptor { | ||
667 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__Descriptor; } | ||
668 | } | ||
669 | |||
670 | protected override pb::FieldAccess.FieldAccessorTable<StorageElement, StorageElement.Builder> InternalFieldAccessors { | ||
671 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageElement__FieldAccessorTable; } | ||
672 | } | ||
673 | |||
674 | #region Nested types | ||
675 | public static class Types { | ||
676 | public enum ReturnStatus { | ||
677 | KEY_MISSING = 4, | ||
678 | INTERNAL_ERROR = 6, | ||
679 | } | ||
680 | |||
681 | } | ||
682 | #endregion | ||
683 | |||
684 | public const int ObjectUuidFieldNumber = 9; | ||
685 | private bool hasObjectUuid; | ||
686 | private pb::ByteString objectUuid_ = pb::ByteString.Empty; | ||
687 | public bool HasObjectUuid { | ||
688 | get { return hasObjectUuid; } | ||
689 | } | ||
690 | public pb::ByteString ObjectUuid { | ||
691 | get { return objectUuid_; } | ||
692 | } | ||
693 | |||
694 | public const int FieldIdFieldNumber = 10; | ||
695 | private bool hasFieldId; | ||
696 | private ulong fieldId_ = 0UL; | ||
697 | public bool HasFieldId { | ||
698 | get { return hasFieldId; } | ||
699 | } | ||
700 | [global::System.CLSCompliant(false)] | ||
701 | public ulong FieldId { | ||
702 | get { return fieldId_; } | ||
703 | } | ||
704 | |||
705 | public const int FieldNameFieldNumber = 11; | ||
706 | private bool hasFieldName; | ||
707 | private string fieldName_ = ""; | ||
708 | public bool HasFieldName { | ||
709 | get { return hasFieldName; } | ||
710 | } | ||
711 | public string FieldName { | ||
712 | get { return fieldName_; } | ||
713 | } | ||
714 | |||
715 | public const int DataFieldNumber = 12; | ||
716 | private bool hasData; | ||
717 | private pb::ByteString data_ = pb::ByteString.Empty; | ||
718 | public bool HasData { | ||
719 | get { return hasData; } | ||
720 | } | ||
721 | public pb::ByteString Data { | ||
722 | get { return data_; } | ||
723 | } | ||
724 | |||
725 | public const int IndexFieldNumber = 13; | ||
726 | private bool hasIndex; | ||
727 | private int index_ = 0; | ||
728 | public bool HasIndex { | ||
729 | get { return hasIndex; } | ||
730 | } | ||
731 | public int Index { | ||
732 | get { return index_; } | ||
733 | } | ||
734 | |||
735 | public const int ReturnStatusFieldNumber = 15; | ||
736 | private bool hasReturnStatus; | ||
737 | private global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING; | ||
738 | public bool HasReturnStatus { | ||
739 | get { return hasReturnStatus; } | ||
740 | } | ||
741 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus ReturnStatus { | ||
742 | get { return returnStatus_; } | ||
743 | } | ||
744 | |||
745 | public override bool IsInitialized { | ||
746 | get { | ||
747 | return true; | ||
748 | } | ||
749 | } | ||
750 | |||
751 | public override void WriteTo(pb::CodedOutputStream output) { | ||
752 | if (HasObjectUuid) { | ||
753 | output.WriteBytes(9, ObjectUuid); | ||
754 | } | ||
755 | if (HasFieldId) { | ||
756 | output.WriteUInt64(10, FieldId); | ||
757 | } | ||
758 | if (HasFieldName) { | ||
759 | output.WriteString(11, FieldName); | ||
760 | } | ||
761 | if (HasData) { | ||
762 | output.WriteBytes(12, Data); | ||
763 | } | ||
764 | if (HasIndex) { | ||
765 | output.WriteInt32(13, Index); | ||
766 | } | ||
767 | if (HasReturnStatus) { | ||
768 | output.WriteEnum(15, (int) ReturnStatus); | ||
769 | } | ||
770 | UnknownFields.WriteTo(output); | ||
771 | } | ||
772 | |||
773 | private int memoizedSerializedSize = -1; | ||
774 | public override int SerializedSize { | ||
775 | get { | ||
776 | int size = memoizedSerializedSize; | ||
777 | if (size != -1) return size; | ||
778 | |||
779 | size = 0; | ||
780 | if (HasObjectUuid) { | ||
781 | size += pb::CodedOutputStream.ComputeBytesSize(9, ObjectUuid); | ||
782 | } | ||
783 | if (HasFieldId) { | ||
784 | size += pb::CodedOutputStream.ComputeUInt64Size(10, FieldId); | ||
785 | } | ||
786 | if (HasFieldName) { | ||
787 | size += pb::CodedOutputStream.ComputeStringSize(11, FieldName); | ||
788 | } | ||
789 | if (HasData) { | ||
790 | size += pb::CodedOutputStream.ComputeBytesSize(12, Data); | ||
791 | } | ||
792 | if (HasIndex) { | ||
793 | size += pb::CodedOutputStream.ComputeInt32Size(13, Index); | ||
794 | } | ||
795 | if (HasReturnStatus) { | ||
796 | size += pb::CodedOutputStream.ComputeEnumSize(15, (int) ReturnStatus); | ||
797 | } | ||
798 | size += UnknownFields.SerializedSize; | ||
799 | memoizedSerializedSize = size; | ||
800 | return size; | ||
801 | } | ||
802 | } | ||
803 | |||
804 | public static StorageElement ParseFrom(pb::ByteString data) { | ||
805 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
806 | } | ||
807 | public static StorageElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
808 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
809 | } | ||
810 | public static StorageElement ParseFrom(byte[] data) { | ||
811 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
812 | } | ||
813 | public static StorageElement ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
814 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
815 | } | ||
816 | public static StorageElement ParseFrom(global::System.IO.Stream input) { | ||
817 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
818 | } | ||
819 | public static StorageElement ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
820 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
821 | } | ||
822 | public static StorageElement ParseDelimitedFrom(global::System.IO.Stream input) { | ||
823 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
824 | } | ||
825 | public static StorageElement ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
826 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
827 | } | ||
828 | public static StorageElement ParseFrom(pb::CodedInputStream input) { | ||
829 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
830 | } | ||
831 | public static StorageElement ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
832 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
833 | } | ||
834 | public static Builder CreateBuilder() { return new Builder(); } | ||
835 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
836 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
837 | public static Builder CreateBuilder(StorageElement prototype) { | ||
838 | return (Builder) new Builder().MergeFrom(prototype); | ||
839 | } | ||
840 | |||
841 | public sealed partial class Builder : pb::GeneratedBuilder<StorageElement, Builder> { | ||
842 | protected override Builder ThisBuilder { | ||
843 | get { return this; } | ||
844 | } | ||
845 | public Builder() {} | ||
846 | |||
847 | StorageElement result = new StorageElement(); | ||
848 | |||
849 | protected override StorageElement MessageBeingBuilt { | ||
850 | get { return result; } | ||
851 | } | ||
852 | |||
853 | public override Builder Clear() { | ||
854 | result = new StorageElement(); | ||
855 | return this; | ||
856 | } | ||
857 | |||
858 | public override Builder Clone() { | ||
859 | return new Builder().MergeFrom(result); | ||
860 | } | ||
861 | |||
862 | public override pbd::MessageDescriptor DescriptorForType { | ||
863 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Descriptor; } | ||
864 | } | ||
865 | |||
866 | public override StorageElement DefaultInstanceForType { | ||
867 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.DefaultInstance; } | ||
868 | } | ||
869 | |||
870 | public override StorageElement BuildPartial() { | ||
871 | if (result == null) { | ||
872 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
873 | } | ||
874 | StorageElement returnMe = result; | ||
875 | result = null; | ||
876 | return returnMe; | ||
877 | } | ||
878 | |||
879 | public override Builder MergeFrom(pb::IMessage other) { | ||
880 | if (other is StorageElement) { | ||
881 | return MergeFrom((StorageElement) other); | ||
882 | } else { | ||
883 | base.MergeFrom(other); | ||
884 | return this; | ||
885 | } | ||
886 | } | ||
887 | |||
888 | public override Builder MergeFrom(StorageElement other) { | ||
889 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.DefaultInstance) return this; | ||
890 | if (other.HasObjectUuid) { | ||
891 | ObjectUuid = other.ObjectUuid; | ||
892 | } | ||
893 | if (other.HasFieldId) { | ||
894 | FieldId = other.FieldId; | ||
895 | } | ||
896 | if (other.HasFieldName) { | ||
897 | FieldName = other.FieldName; | ||
898 | } | ||
899 | if (other.HasData) { | ||
900 | Data = other.Data; | ||
901 | } | ||
902 | if (other.HasIndex) { | ||
903 | Index = other.Index; | ||
904 | } | ||
905 | if (other.HasReturnStatus) { | ||
906 | ReturnStatus = other.ReturnStatus; | ||
907 | } | ||
908 | this.MergeUnknownFields(other.UnknownFields); | ||
909 | return this; | ||
910 | } | ||
911 | |||
912 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
913 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
914 | } | ||
915 | |||
916 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
917 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
918 | while (true) { | ||
919 | uint tag = input.ReadTag(); | ||
920 | switch (tag) { | ||
921 | case 0: { | ||
922 | if (unknownFields != null) { | ||
923 | this.UnknownFields = unknownFields.Build(); | ||
924 | } | ||
925 | return this; | ||
926 | } | ||
927 | default: { | ||
928 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
929 | if (unknownFields != null) { | ||
930 | this.UnknownFields = unknownFields.Build(); | ||
931 | } | ||
932 | return this; | ||
933 | } | ||
934 | if (unknownFields == null) { | ||
935 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
936 | } | ||
937 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
938 | break; | ||
939 | } | ||
940 | case 74: { | ||
941 | ObjectUuid = input.ReadBytes(); | ||
942 | break; | ||
943 | } | ||
944 | case 80: { | ||
945 | FieldId = input.ReadUInt64(); | ||
946 | break; | ||
947 | } | ||
948 | case 90: { | ||
949 | FieldName = input.ReadString(); | ||
950 | break; | ||
951 | } | ||
952 | case 98: { | ||
953 | Data = input.ReadBytes(); | ||
954 | break; | ||
955 | } | ||
956 | case 104: { | ||
957 | Index = input.ReadInt32(); | ||
958 | break; | ||
959 | } | ||
960 | case 120: { | ||
961 | int rawValue = input.ReadEnum(); | ||
962 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus), rawValue)) { | ||
963 | if (unknownFields == null) { | ||
964 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
965 | } | ||
966 | unknownFields.MergeVarintField(15, (ulong) rawValue); | ||
967 | } else { | ||
968 | ReturnStatus = (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus) rawValue; | ||
969 | } | ||
970 | break; | ||
971 | } | ||
972 | } | ||
973 | } | ||
974 | } | ||
975 | |||
976 | |||
977 | public bool HasObjectUuid { | ||
978 | get { return result.HasObjectUuid; } | ||
979 | } | ||
980 | public pb::ByteString ObjectUuid { | ||
981 | get { return result.ObjectUuid; } | ||
982 | set { SetObjectUuid(value); } | ||
983 | } | ||
984 | public Builder SetObjectUuid(pb::ByteString value) { | ||
985 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
986 | result.hasObjectUuid = true; | ||
987 | result.objectUuid_ = value; | ||
988 | return this; | ||
989 | } | ||
990 | public Builder ClearObjectUuid() { | ||
991 | result.hasObjectUuid = false; | ||
992 | result.objectUuid_ = pb::ByteString.Empty; | ||
993 | return this; | ||
994 | } | ||
995 | |||
996 | public bool HasFieldId { | ||
997 | get { return result.HasFieldId; } | ||
998 | } | ||
999 | [global::System.CLSCompliant(false)] | ||
1000 | public ulong FieldId { | ||
1001 | get { return result.FieldId; } | ||
1002 | set { SetFieldId(value); } | ||
1003 | } | ||
1004 | [global::System.CLSCompliant(false)] | ||
1005 | public Builder SetFieldId(ulong value) { | ||
1006 | result.hasFieldId = true; | ||
1007 | result.fieldId_ = value; | ||
1008 | return this; | ||
1009 | } | ||
1010 | public Builder ClearFieldId() { | ||
1011 | result.hasFieldId = false; | ||
1012 | result.fieldId_ = 0UL; | ||
1013 | return this; | ||
1014 | } | ||
1015 | |||
1016 | public bool HasFieldName { | ||
1017 | get { return result.HasFieldName; } | ||
1018 | } | ||
1019 | public string FieldName { | ||
1020 | get { return result.FieldName; } | ||
1021 | set { SetFieldName(value); } | ||
1022 | } | ||
1023 | public Builder SetFieldName(string value) { | ||
1024 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1025 | result.hasFieldName = true; | ||
1026 | result.fieldName_ = value; | ||
1027 | return this; | ||
1028 | } | ||
1029 | public Builder ClearFieldName() { | ||
1030 | result.hasFieldName = false; | ||
1031 | result.fieldName_ = ""; | ||
1032 | return this; | ||
1033 | } | ||
1034 | |||
1035 | public bool HasData { | ||
1036 | get { return result.HasData; } | ||
1037 | } | ||
1038 | public pb::ByteString Data { | ||
1039 | get { return result.Data; } | ||
1040 | set { SetData(value); } | ||
1041 | } | ||
1042 | public Builder SetData(pb::ByteString value) { | ||
1043 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1044 | result.hasData = true; | ||
1045 | result.data_ = value; | ||
1046 | return this; | ||
1047 | } | ||
1048 | public Builder ClearData() { | ||
1049 | result.hasData = false; | ||
1050 | result.data_ = pb::ByteString.Empty; | ||
1051 | return this; | ||
1052 | } | ||
1053 | |||
1054 | public bool HasIndex { | ||
1055 | get { return result.HasIndex; } | ||
1056 | } | ||
1057 | public int Index { | ||
1058 | get { return result.Index; } | ||
1059 | set { SetIndex(value); } | ||
1060 | } | ||
1061 | public Builder SetIndex(int value) { | ||
1062 | result.hasIndex = true; | ||
1063 | result.index_ = value; | ||
1064 | return this; | ||
1065 | } | ||
1066 | public Builder ClearIndex() { | ||
1067 | result.hasIndex = false; | ||
1068 | result.index_ = 0; | ||
1069 | return this; | ||
1070 | } | ||
1071 | |||
1072 | public bool HasReturnStatus { | ||
1073 | get { return result.HasReturnStatus; } | ||
1074 | } | ||
1075 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus ReturnStatus { | ||
1076 | get { return result.ReturnStatus; } | ||
1077 | set { SetReturnStatus(value); } | ||
1078 | } | ||
1079 | public Builder SetReturnStatus(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus value) { | ||
1080 | result.hasReturnStatus = true; | ||
1081 | result.returnStatus_ = value; | ||
1082 | return this; | ||
1083 | } | ||
1084 | public Builder ClearReturnStatus() { | ||
1085 | result.hasReturnStatus = false; | ||
1086 | result.returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING; | ||
1087 | return this; | ||
1088 | } | ||
1089 | } | ||
1090 | static StorageElement() { | ||
1091 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
1092 | } | ||
1093 | } | ||
1094 | |||
1095 | public sealed partial class CompareElement : pb::GeneratedMessage<CompareElement, CompareElement.Builder> { | ||
1096 | private static readonly CompareElement defaultInstance = new Builder().BuildPartial(); | ||
1097 | public static CompareElement DefaultInstance { | ||
1098 | get { return defaultInstance; } | ||
1099 | } | ||
1100 | |||
1101 | public override CompareElement DefaultInstanceForType { | ||
1102 | get { return defaultInstance; } | ||
1103 | } | ||
1104 | |||
1105 | protected override CompareElement ThisMessage { | ||
1106 | get { return this; } | ||
1107 | } | ||
1108 | |||
1109 | public static pbd::MessageDescriptor Descriptor { | ||
1110 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__Descriptor; } | ||
1111 | } | ||
1112 | |||
1113 | protected override pb::FieldAccess.FieldAccessorTable<CompareElement, CompareElement.Builder> InternalFieldAccessors { | ||
1114 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_CompareElement__FieldAccessorTable; } | ||
1115 | } | ||
1116 | |||
1117 | #region Nested types | ||
1118 | public static class Types { | ||
1119 | public enum COMPARATOR { | ||
1120 | EQUAL = 0, | ||
1121 | NEQUAL = 1, | ||
1122 | } | ||
1123 | |||
1124 | } | ||
1125 | #endregion | ||
1126 | |||
1127 | public const int ObjectUuidFieldNumber = 9; | ||
1128 | private bool hasObjectUuid; | ||
1129 | private pb::ByteString objectUuid_ = pb::ByteString.Empty; | ||
1130 | public bool HasObjectUuid { | ||
1131 | get { return hasObjectUuid; } | ||
1132 | } | ||
1133 | public pb::ByteString ObjectUuid { | ||
1134 | get { return objectUuid_; } | ||
1135 | } | ||
1136 | |||
1137 | public const int FieldIdFieldNumber = 10; | ||
1138 | private bool hasFieldId; | ||
1139 | private ulong fieldId_ = 0UL; | ||
1140 | public bool HasFieldId { | ||
1141 | get { return hasFieldId; } | ||
1142 | } | ||
1143 | [global::System.CLSCompliant(false)] | ||
1144 | public ulong FieldId { | ||
1145 | get { return fieldId_; } | ||
1146 | } | ||
1147 | |||
1148 | public const int FieldNameFieldNumber = 11; | ||
1149 | private bool hasFieldName; | ||
1150 | private string fieldName_ = ""; | ||
1151 | public bool HasFieldName { | ||
1152 | get { return hasFieldName; } | ||
1153 | } | ||
1154 | public string FieldName { | ||
1155 | get { return fieldName_; } | ||
1156 | } | ||
1157 | |||
1158 | public const int DataFieldNumber = 12; | ||
1159 | private bool hasData; | ||
1160 | private pb::ByteString data_ = pb::ByteString.Empty; | ||
1161 | public bool HasData { | ||
1162 | get { return hasData; } | ||
1163 | } | ||
1164 | public pb::ByteString Data { | ||
1165 | get { return data_; } | ||
1166 | } | ||
1167 | |||
1168 | public const int ComparatorFieldNumber = 14; | ||
1169 | private bool hasComparator; | ||
1170 | private global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR comparator_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL; | ||
1171 | public bool HasComparator { | ||
1172 | get { return hasComparator; } | ||
1173 | } | ||
1174 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR Comparator { | ||
1175 | get { return comparator_; } | ||
1176 | } | ||
1177 | |||
1178 | public override bool IsInitialized { | ||
1179 | get { | ||
1180 | return true; | ||
1181 | } | ||
1182 | } | ||
1183 | |||
1184 | public override void WriteTo(pb::CodedOutputStream output) { | ||
1185 | if (HasObjectUuid) { | ||
1186 | output.WriteBytes(9, ObjectUuid); | ||
1187 | } | ||
1188 | if (HasFieldId) { | ||
1189 | output.WriteUInt64(10, FieldId); | ||
1190 | } | ||
1191 | if (HasFieldName) { | ||
1192 | output.WriteString(11, FieldName); | ||
1193 | } | ||
1194 | if (HasData) { | ||
1195 | output.WriteBytes(12, Data); | ||
1196 | } | ||
1197 | if (HasComparator) { | ||
1198 | output.WriteEnum(14, (int) Comparator); | ||
1199 | } | ||
1200 | UnknownFields.WriteTo(output); | ||
1201 | } | ||
1202 | |||
1203 | private int memoizedSerializedSize = -1; | ||
1204 | public override int SerializedSize { | ||
1205 | get { | ||
1206 | int size = memoizedSerializedSize; | ||
1207 | if (size != -1) return size; | ||
1208 | |||
1209 | size = 0; | ||
1210 | if (HasObjectUuid) { | ||
1211 | size += pb::CodedOutputStream.ComputeBytesSize(9, ObjectUuid); | ||
1212 | } | ||
1213 | if (HasFieldId) { | ||
1214 | size += pb::CodedOutputStream.ComputeUInt64Size(10, FieldId); | ||
1215 | } | ||
1216 | if (HasFieldName) { | ||
1217 | size += pb::CodedOutputStream.ComputeStringSize(11, FieldName); | ||
1218 | } | ||
1219 | if (HasData) { | ||
1220 | size += pb::CodedOutputStream.ComputeBytesSize(12, Data); | ||
1221 | } | ||
1222 | if (HasComparator) { | ||
1223 | size += pb::CodedOutputStream.ComputeEnumSize(14, (int) Comparator); | ||
1224 | } | ||
1225 | size += UnknownFields.SerializedSize; | ||
1226 | memoizedSerializedSize = size; | ||
1227 | return size; | ||
1228 | } | ||
1229 | } | ||
1230 | |||
1231 | public static CompareElement ParseFrom(pb::ByteString data) { | ||
1232 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1233 | } | ||
1234 | public static CompareElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
1235 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1236 | } | ||
1237 | public static CompareElement ParseFrom(byte[] data) { | ||
1238 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1239 | } | ||
1240 | public static CompareElement ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
1241 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1242 | } | ||
1243 | public static CompareElement ParseFrom(global::System.IO.Stream input) { | ||
1244 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1245 | } | ||
1246 | public static CompareElement ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1247 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1248 | } | ||
1249 | public static CompareElement ParseDelimitedFrom(global::System.IO.Stream input) { | ||
1250 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
1251 | } | ||
1252 | public static CompareElement ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1253 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
1254 | } | ||
1255 | public static CompareElement ParseFrom(pb::CodedInputStream input) { | ||
1256 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1257 | } | ||
1258 | public static CompareElement ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1259 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1260 | } | ||
1261 | public static Builder CreateBuilder() { return new Builder(); } | ||
1262 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
1263 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
1264 | public static Builder CreateBuilder(CompareElement prototype) { | ||
1265 | return (Builder) new Builder().MergeFrom(prototype); | ||
1266 | } | ||
1267 | |||
1268 | public sealed partial class Builder : pb::GeneratedBuilder<CompareElement, Builder> { | ||
1269 | protected override Builder ThisBuilder { | ||
1270 | get { return this; } | ||
1271 | } | ||
1272 | public Builder() {} | ||
1273 | |||
1274 | CompareElement result = new CompareElement(); | ||
1275 | |||
1276 | protected override CompareElement MessageBeingBuilt { | ||
1277 | get { return result; } | ||
1278 | } | ||
1279 | |||
1280 | public override Builder Clear() { | ||
1281 | result = new CompareElement(); | ||
1282 | return this; | ||
1283 | } | ||
1284 | |||
1285 | public override Builder Clone() { | ||
1286 | return new Builder().MergeFrom(result); | ||
1287 | } | ||
1288 | |||
1289 | public override pbd::MessageDescriptor DescriptorForType { | ||
1290 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Descriptor; } | ||
1291 | } | ||
1292 | |||
1293 | public override CompareElement DefaultInstanceForType { | ||
1294 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.DefaultInstance; } | ||
1295 | } | ||
1296 | |||
1297 | public override CompareElement BuildPartial() { | ||
1298 | if (result == null) { | ||
1299 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
1300 | } | ||
1301 | CompareElement returnMe = result; | ||
1302 | result = null; | ||
1303 | return returnMe; | ||
1304 | } | ||
1305 | |||
1306 | public override Builder MergeFrom(pb::IMessage other) { | ||
1307 | if (other is CompareElement) { | ||
1308 | return MergeFrom((CompareElement) other); | ||
1309 | } else { | ||
1310 | base.MergeFrom(other); | ||
1311 | return this; | ||
1312 | } | ||
1313 | } | ||
1314 | |||
1315 | public override Builder MergeFrom(CompareElement other) { | ||
1316 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.DefaultInstance) return this; | ||
1317 | if (other.HasObjectUuid) { | ||
1318 | ObjectUuid = other.ObjectUuid; | ||
1319 | } | ||
1320 | if (other.HasFieldId) { | ||
1321 | FieldId = other.FieldId; | ||
1322 | } | ||
1323 | if (other.HasFieldName) { | ||
1324 | FieldName = other.FieldName; | ||
1325 | } | ||
1326 | if (other.HasData) { | ||
1327 | Data = other.Data; | ||
1328 | } | ||
1329 | if (other.HasComparator) { | ||
1330 | Comparator = other.Comparator; | ||
1331 | } | ||
1332 | this.MergeUnknownFields(other.UnknownFields); | ||
1333 | return this; | ||
1334 | } | ||
1335 | |||
1336 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
1337 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
1338 | } | ||
1339 | |||
1340 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1341 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
1342 | while (true) { | ||
1343 | uint tag = input.ReadTag(); | ||
1344 | switch (tag) { | ||
1345 | case 0: { | ||
1346 | if (unknownFields != null) { | ||
1347 | this.UnknownFields = unknownFields.Build(); | ||
1348 | } | ||
1349 | return this; | ||
1350 | } | ||
1351 | default: { | ||
1352 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
1353 | if (unknownFields != null) { | ||
1354 | this.UnknownFields = unknownFields.Build(); | ||
1355 | } | ||
1356 | return this; | ||
1357 | } | ||
1358 | if (unknownFields == null) { | ||
1359 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
1360 | } | ||
1361 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
1362 | break; | ||
1363 | } | ||
1364 | case 74: { | ||
1365 | ObjectUuid = input.ReadBytes(); | ||
1366 | break; | ||
1367 | } | ||
1368 | case 80: { | ||
1369 | FieldId = input.ReadUInt64(); | ||
1370 | break; | ||
1371 | } | ||
1372 | case 90: { | ||
1373 | FieldName = input.ReadString(); | ||
1374 | break; | ||
1375 | } | ||
1376 | case 98: { | ||
1377 | Data = input.ReadBytes(); | ||
1378 | break; | ||
1379 | } | ||
1380 | case 112: { | ||
1381 | int rawValue = input.ReadEnum(); | ||
1382 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR), rawValue)) { | ||
1383 | if (unknownFields == null) { | ||
1384 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
1385 | } | ||
1386 | unknownFields.MergeVarintField(14, (ulong) rawValue); | ||
1387 | } else { | ||
1388 | Comparator = (global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR) rawValue; | ||
1389 | } | ||
1390 | break; | ||
1391 | } | ||
1392 | } | ||
1393 | } | ||
1394 | } | ||
1395 | |||
1396 | |||
1397 | public bool HasObjectUuid { | ||
1398 | get { return result.HasObjectUuid; } | ||
1399 | } | ||
1400 | public pb::ByteString ObjectUuid { | ||
1401 | get { return result.ObjectUuid; } | ||
1402 | set { SetObjectUuid(value); } | ||
1403 | } | ||
1404 | public Builder SetObjectUuid(pb::ByteString value) { | ||
1405 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1406 | result.hasObjectUuid = true; | ||
1407 | result.objectUuid_ = value; | ||
1408 | return this; | ||
1409 | } | ||
1410 | public Builder ClearObjectUuid() { | ||
1411 | result.hasObjectUuid = false; | ||
1412 | result.objectUuid_ = pb::ByteString.Empty; | ||
1413 | return this; | ||
1414 | } | ||
1415 | |||
1416 | public bool HasFieldId { | ||
1417 | get { return result.HasFieldId; } | ||
1418 | } | ||
1419 | [global::System.CLSCompliant(false)] | ||
1420 | public ulong FieldId { | ||
1421 | get { return result.FieldId; } | ||
1422 | set { SetFieldId(value); } | ||
1423 | } | ||
1424 | [global::System.CLSCompliant(false)] | ||
1425 | public Builder SetFieldId(ulong value) { | ||
1426 | result.hasFieldId = true; | ||
1427 | result.fieldId_ = value; | ||
1428 | return this; | ||
1429 | } | ||
1430 | public Builder ClearFieldId() { | ||
1431 | result.hasFieldId = false; | ||
1432 | result.fieldId_ = 0UL; | ||
1433 | return this; | ||
1434 | } | ||
1435 | |||
1436 | public bool HasFieldName { | ||
1437 | get { return result.HasFieldName; } | ||
1438 | } | ||
1439 | public string FieldName { | ||
1440 | get { return result.FieldName; } | ||
1441 | set { SetFieldName(value); } | ||
1442 | } | ||
1443 | public Builder SetFieldName(string value) { | ||
1444 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1445 | result.hasFieldName = true; | ||
1446 | result.fieldName_ = value; | ||
1447 | return this; | ||
1448 | } | ||
1449 | public Builder ClearFieldName() { | ||
1450 | result.hasFieldName = false; | ||
1451 | result.fieldName_ = ""; | ||
1452 | return this; | ||
1453 | } | ||
1454 | |||
1455 | public bool HasData { | ||
1456 | get { return result.HasData; } | ||
1457 | } | ||
1458 | public pb::ByteString Data { | ||
1459 | get { return result.Data; } | ||
1460 | set { SetData(value); } | ||
1461 | } | ||
1462 | public Builder SetData(pb::ByteString value) { | ||
1463 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1464 | result.hasData = true; | ||
1465 | result.data_ = value; | ||
1466 | return this; | ||
1467 | } | ||
1468 | public Builder ClearData() { | ||
1469 | result.hasData = false; | ||
1470 | result.data_ = pb::ByteString.Empty; | ||
1471 | return this; | ||
1472 | } | ||
1473 | |||
1474 | public bool HasComparator { | ||
1475 | get { return result.HasComparator; } | ||
1476 | } | ||
1477 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR Comparator { | ||
1478 | get { return result.Comparator; } | ||
1479 | set { SetComparator(value); } | ||
1480 | } | ||
1481 | public Builder SetComparator(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR value) { | ||
1482 | result.hasComparator = true; | ||
1483 | result.comparator_ = value; | ||
1484 | return this; | ||
1485 | } | ||
1486 | public Builder ClearComparator() { | ||
1487 | result.hasComparator = false; | ||
1488 | result.comparator_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL; | ||
1489 | return this; | ||
1490 | } | ||
1491 | } | ||
1492 | static CompareElement() { | ||
1493 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
1494 | } | ||
1495 | } | ||
1496 | |||
1497 | public sealed partial class StorageSet : pb::GeneratedMessage<StorageSet, StorageSet.Builder> { | ||
1498 | private static readonly StorageSet defaultInstance = new Builder().BuildPartial(); | ||
1499 | public static StorageSet DefaultInstance { | ||
1500 | get { return defaultInstance; } | ||
1501 | } | ||
1502 | |||
1503 | public override StorageSet DefaultInstanceForType { | ||
1504 | get { return defaultInstance; } | ||
1505 | } | ||
1506 | |||
1507 | protected override StorageSet ThisMessage { | ||
1508 | get { return this; } | ||
1509 | } | ||
1510 | |||
1511 | public static pbd::MessageDescriptor Descriptor { | ||
1512 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__Descriptor; } | ||
1513 | } | ||
1514 | |||
1515 | protected override pb::FieldAccess.FieldAccessorTable<StorageSet, StorageSet.Builder> InternalFieldAccessors { | ||
1516 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_StorageSet__FieldAccessorTable; } | ||
1517 | } | ||
1518 | |||
1519 | public const int ReadsFieldNumber = 9; | ||
1520 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> reads_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
1521 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
1522 | get { return reads_; } | ||
1523 | } | ||
1524 | public int ReadsCount { | ||
1525 | get { return reads_.Count; } | ||
1526 | } | ||
1527 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
1528 | return reads_[index]; | ||
1529 | } | ||
1530 | |||
1531 | public override bool IsInitialized { | ||
1532 | get { | ||
1533 | return true; | ||
1534 | } | ||
1535 | } | ||
1536 | |||
1537 | public override void WriteTo(pb::CodedOutputStream output) { | ||
1538 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
1539 | output.WriteMessage(9, element); | ||
1540 | } | ||
1541 | UnknownFields.WriteTo(output); | ||
1542 | } | ||
1543 | |||
1544 | private int memoizedSerializedSize = -1; | ||
1545 | public override int SerializedSize { | ||
1546 | get { | ||
1547 | int size = memoizedSerializedSize; | ||
1548 | if (size != -1) return size; | ||
1549 | |||
1550 | size = 0; | ||
1551 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
1552 | size += pb::CodedOutputStream.ComputeMessageSize(9, element); | ||
1553 | } | ||
1554 | size += UnknownFields.SerializedSize; | ||
1555 | memoizedSerializedSize = size; | ||
1556 | return size; | ||
1557 | } | ||
1558 | } | ||
1559 | |||
1560 | public static StorageSet ParseFrom(pb::ByteString data) { | ||
1561 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1562 | } | ||
1563 | public static StorageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
1564 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1565 | } | ||
1566 | public static StorageSet ParseFrom(byte[] data) { | ||
1567 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1568 | } | ||
1569 | public static StorageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
1570 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1571 | } | ||
1572 | public static StorageSet ParseFrom(global::System.IO.Stream input) { | ||
1573 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1574 | } | ||
1575 | public static StorageSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1576 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1577 | } | ||
1578 | public static StorageSet ParseDelimitedFrom(global::System.IO.Stream input) { | ||
1579 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
1580 | } | ||
1581 | public static StorageSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1582 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
1583 | } | ||
1584 | public static StorageSet ParseFrom(pb::CodedInputStream input) { | ||
1585 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1586 | } | ||
1587 | public static StorageSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1588 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1589 | } | ||
1590 | public static Builder CreateBuilder() { return new Builder(); } | ||
1591 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
1592 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
1593 | public static Builder CreateBuilder(StorageSet prototype) { | ||
1594 | return (Builder) new Builder().MergeFrom(prototype); | ||
1595 | } | ||
1596 | |||
1597 | public sealed partial class Builder : pb::GeneratedBuilder<StorageSet, Builder> { | ||
1598 | protected override Builder ThisBuilder { | ||
1599 | get { return this; } | ||
1600 | } | ||
1601 | public Builder() {} | ||
1602 | |||
1603 | StorageSet result = new StorageSet(); | ||
1604 | |||
1605 | protected override StorageSet MessageBeingBuilt { | ||
1606 | get { return result; } | ||
1607 | } | ||
1608 | |||
1609 | public override Builder Clear() { | ||
1610 | result = new StorageSet(); | ||
1611 | return this; | ||
1612 | } | ||
1613 | |||
1614 | public override Builder Clone() { | ||
1615 | return new Builder().MergeFrom(result); | ||
1616 | } | ||
1617 | |||
1618 | public override pbd::MessageDescriptor DescriptorForType { | ||
1619 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.Descriptor; } | ||
1620 | } | ||
1621 | |||
1622 | public override StorageSet DefaultInstanceForType { | ||
1623 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.DefaultInstance; } | ||
1624 | } | ||
1625 | |||
1626 | public override StorageSet BuildPartial() { | ||
1627 | if (result == null) { | ||
1628 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
1629 | } | ||
1630 | result.reads_.MakeReadOnly(); | ||
1631 | StorageSet returnMe = result; | ||
1632 | result = null; | ||
1633 | return returnMe; | ||
1634 | } | ||
1635 | |||
1636 | public override Builder MergeFrom(pb::IMessage other) { | ||
1637 | if (other is StorageSet) { | ||
1638 | return MergeFrom((StorageSet) other); | ||
1639 | } else { | ||
1640 | base.MergeFrom(other); | ||
1641 | return this; | ||
1642 | } | ||
1643 | } | ||
1644 | |||
1645 | public override Builder MergeFrom(StorageSet other) { | ||
1646 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageSet.DefaultInstance) return this; | ||
1647 | if (other.reads_.Count != 0) { | ||
1648 | base.AddRange(other.reads_, result.reads_); | ||
1649 | } | ||
1650 | this.MergeUnknownFields(other.UnknownFields); | ||
1651 | return this; | ||
1652 | } | ||
1653 | |||
1654 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
1655 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
1656 | } | ||
1657 | |||
1658 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1659 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
1660 | while (true) { | ||
1661 | uint tag = input.ReadTag(); | ||
1662 | switch (tag) { | ||
1663 | case 0: { | ||
1664 | if (unknownFields != null) { | ||
1665 | this.UnknownFields = unknownFields.Build(); | ||
1666 | } | ||
1667 | return this; | ||
1668 | } | ||
1669 | default: { | ||
1670 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
1671 | if (unknownFields != null) { | ||
1672 | this.UnknownFields = unknownFields.Build(); | ||
1673 | } | ||
1674 | return this; | ||
1675 | } | ||
1676 | if (unknownFields == null) { | ||
1677 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
1678 | } | ||
1679 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
1680 | break; | ||
1681 | } | ||
1682 | case 74: { | ||
1683 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
1684 | input.ReadMessage(subBuilder, extensionRegistry); | ||
1685 | AddReads(subBuilder.BuildPartial()); | ||
1686 | break; | ||
1687 | } | ||
1688 | } | ||
1689 | } | ||
1690 | } | ||
1691 | |||
1692 | |||
1693 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
1694 | get { return result.reads_; } | ||
1695 | } | ||
1696 | public int ReadsCount { | ||
1697 | get { return result.ReadsCount; } | ||
1698 | } | ||
1699 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
1700 | return result.GetReads(index); | ||
1701 | } | ||
1702 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
1703 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1704 | result.reads_[index] = value; | ||
1705 | return this; | ||
1706 | } | ||
1707 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
1708 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
1709 | result.reads_[index] = builderForValue.Build(); | ||
1710 | return this; | ||
1711 | } | ||
1712 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
1713 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1714 | result.reads_.Add(value); | ||
1715 | return this; | ||
1716 | } | ||
1717 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
1718 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
1719 | result.reads_.Add(builderForValue.Build()); | ||
1720 | return this; | ||
1721 | } | ||
1722 | public Builder AddRangeReads(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
1723 | base.AddRange(values, result.reads_); | ||
1724 | return this; | ||
1725 | } | ||
1726 | public Builder ClearReads() { | ||
1727 | result.reads_.Clear(); | ||
1728 | return this; | ||
1729 | } | ||
1730 | } | ||
1731 | static StorageSet() { | ||
1732 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
1733 | } | ||
1734 | } | ||
1735 | |||
1736 | public sealed partial class ReadSet : pb::GeneratedMessage<ReadSet, ReadSet.Builder> { | ||
1737 | private static readonly ReadSet defaultInstance = new Builder().BuildPartial(); | ||
1738 | public static ReadSet DefaultInstance { | ||
1739 | get { return defaultInstance; } | ||
1740 | } | ||
1741 | |||
1742 | public override ReadSet DefaultInstanceForType { | ||
1743 | get { return defaultInstance; } | ||
1744 | } | ||
1745 | |||
1746 | protected override ReadSet ThisMessage { | ||
1747 | get { return this; } | ||
1748 | } | ||
1749 | |||
1750 | public static pbd::MessageDescriptor Descriptor { | ||
1751 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__Descriptor; } | ||
1752 | } | ||
1753 | |||
1754 | protected override pb::FieldAccess.FieldAccessorTable<ReadSet, ReadSet.Builder> InternalFieldAccessors { | ||
1755 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadSet__FieldAccessorTable; } | ||
1756 | } | ||
1757 | |||
1758 | public const int ReadsFieldNumber = 9; | ||
1759 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> reads_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
1760 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
1761 | get { return reads_; } | ||
1762 | } | ||
1763 | public int ReadsCount { | ||
1764 | get { return reads_.Count; } | ||
1765 | } | ||
1766 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
1767 | return reads_[index]; | ||
1768 | } | ||
1769 | |||
1770 | public override bool IsInitialized { | ||
1771 | get { | ||
1772 | return true; | ||
1773 | } | ||
1774 | } | ||
1775 | |||
1776 | public override void WriteTo(pb::CodedOutputStream output) { | ||
1777 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
1778 | output.WriteMessage(9, element); | ||
1779 | } | ||
1780 | UnknownFields.WriteTo(output); | ||
1781 | } | ||
1782 | |||
1783 | private int memoizedSerializedSize = -1; | ||
1784 | public override int SerializedSize { | ||
1785 | get { | ||
1786 | int size = memoizedSerializedSize; | ||
1787 | if (size != -1) return size; | ||
1788 | |||
1789 | size = 0; | ||
1790 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
1791 | size += pb::CodedOutputStream.ComputeMessageSize(9, element); | ||
1792 | } | ||
1793 | size += UnknownFields.SerializedSize; | ||
1794 | memoizedSerializedSize = size; | ||
1795 | return size; | ||
1796 | } | ||
1797 | } | ||
1798 | |||
1799 | public static ReadSet ParseFrom(pb::ByteString data) { | ||
1800 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1801 | } | ||
1802 | public static ReadSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
1803 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1804 | } | ||
1805 | public static ReadSet ParseFrom(byte[] data) { | ||
1806 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1807 | } | ||
1808 | public static ReadSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
1809 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1810 | } | ||
1811 | public static ReadSet ParseFrom(global::System.IO.Stream input) { | ||
1812 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1813 | } | ||
1814 | public static ReadSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1815 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1816 | } | ||
1817 | public static ReadSet ParseDelimitedFrom(global::System.IO.Stream input) { | ||
1818 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
1819 | } | ||
1820 | public static ReadSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1821 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
1822 | } | ||
1823 | public static ReadSet ParseFrom(pb::CodedInputStream input) { | ||
1824 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1825 | } | ||
1826 | public static ReadSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1827 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1828 | } | ||
1829 | public static Builder CreateBuilder() { return new Builder(); } | ||
1830 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
1831 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
1832 | public static Builder CreateBuilder(ReadSet prototype) { | ||
1833 | return (Builder) new Builder().MergeFrom(prototype); | ||
1834 | } | ||
1835 | |||
1836 | public sealed partial class Builder : pb::GeneratedBuilder<ReadSet, Builder> { | ||
1837 | protected override Builder ThisBuilder { | ||
1838 | get { return this; } | ||
1839 | } | ||
1840 | public Builder() {} | ||
1841 | |||
1842 | ReadSet result = new ReadSet(); | ||
1843 | |||
1844 | protected override ReadSet MessageBeingBuilt { | ||
1845 | get { return result; } | ||
1846 | } | ||
1847 | |||
1848 | public override Builder Clear() { | ||
1849 | result = new ReadSet(); | ||
1850 | return this; | ||
1851 | } | ||
1852 | |||
1853 | public override Builder Clone() { | ||
1854 | return new Builder().MergeFrom(result); | ||
1855 | } | ||
1856 | |||
1857 | public override pbd::MessageDescriptor DescriptorForType { | ||
1858 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.Descriptor; } | ||
1859 | } | ||
1860 | |||
1861 | public override ReadSet DefaultInstanceForType { | ||
1862 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.DefaultInstance; } | ||
1863 | } | ||
1864 | |||
1865 | public override ReadSet BuildPartial() { | ||
1866 | if (result == null) { | ||
1867 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
1868 | } | ||
1869 | result.reads_.MakeReadOnly(); | ||
1870 | ReadSet returnMe = result; | ||
1871 | result = null; | ||
1872 | return returnMe; | ||
1873 | } | ||
1874 | |||
1875 | public override Builder MergeFrom(pb::IMessage other) { | ||
1876 | if (other is ReadSet) { | ||
1877 | return MergeFrom((ReadSet) other); | ||
1878 | } else { | ||
1879 | base.MergeFrom(other); | ||
1880 | return this; | ||
1881 | } | ||
1882 | } | ||
1883 | |||
1884 | public override Builder MergeFrom(ReadSet other) { | ||
1885 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadSet.DefaultInstance) return this; | ||
1886 | if (other.reads_.Count != 0) { | ||
1887 | base.AddRange(other.reads_, result.reads_); | ||
1888 | } | ||
1889 | this.MergeUnknownFields(other.UnknownFields); | ||
1890 | return this; | ||
1891 | } | ||
1892 | |||
1893 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
1894 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
1895 | } | ||
1896 | |||
1897 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1898 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
1899 | while (true) { | ||
1900 | uint tag = input.ReadTag(); | ||
1901 | switch (tag) { | ||
1902 | case 0: { | ||
1903 | if (unknownFields != null) { | ||
1904 | this.UnknownFields = unknownFields.Build(); | ||
1905 | } | ||
1906 | return this; | ||
1907 | } | ||
1908 | default: { | ||
1909 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
1910 | if (unknownFields != null) { | ||
1911 | this.UnknownFields = unknownFields.Build(); | ||
1912 | } | ||
1913 | return this; | ||
1914 | } | ||
1915 | if (unknownFields == null) { | ||
1916 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
1917 | } | ||
1918 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
1919 | break; | ||
1920 | } | ||
1921 | case 74: { | ||
1922 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
1923 | input.ReadMessage(subBuilder, extensionRegistry); | ||
1924 | AddReads(subBuilder.BuildPartial()); | ||
1925 | break; | ||
1926 | } | ||
1927 | } | ||
1928 | } | ||
1929 | } | ||
1930 | |||
1931 | |||
1932 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
1933 | get { return result.reads_; } | ||
1934 | } | ||
1935 | public int ReadsCount { | ||
1936 | get { return result.ReadsCount; } | ||
1937 | } | ||
1938 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
1939 | return result.GetReads(index); | ||
1940 | } | ||
1941 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
1942 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1943 | result.reads_[index] = value; | ||
1944 | return this; | ||
1945 | } | ||
1946 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
1947 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
1948 | result.reads_[index] = builderForValue.Build(); | ||
1949 | return this; | ||
1950 | } | ||
1951 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
1952 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1953 | result.reads_.Add(value); | ||
1954 | return this; | ||
1955 | } | ||
1956 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
1957 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
1958 | result.reads_.Add(builderForValue.Build()); | ||
1959 | return this; | ||
1960 | } | ||
1961 | public Builder AddRangeReads(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
1962 | base.AddRange(values, result.reads_); | ||
1963 | return this; | ||
1964 | } | ||
1965 | public Builder ClearReads() { | ||
1966 | result.reads_.Clear(); | ||
1967 | return this; | ||
1968 | } | ||
1969 | } | ||
1970 | static ReadSet() { | ||
1971 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
1972 | } | ||
1973 | } | ||
1974 | |||
1975 | public sealed partial class WriteSet : pb::GeneratedMessage<WriteSet, WriteSet.Builder> { | ||
1976 | private static readonly WriteSet defaultInstance = new Builder().BuildPartial(); | ||
1977 | public static WriteSet DefaultInstance { | ||
1978 | get { return defaultInstance; } | ||
1979 | } | ||
1980 | |||
1981 | public override WriteSet DefaultInstanceForType { | ||
1982 | get { return defaultInstance; } | ||
1983 | } | ||
1984 | |||
1985 | protected override WriteSet ThisMessage { | ||
1986 | get { return this; } | ||
1987 | } | ||
1988 | |||
1989 | public static pbd::MessageDescriptor Descriptor { | ||
1990 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__Descriptor; } | ||
1991 | } | ||
1992 | |||
1993 | protected override pb::FieldAccess.FieldAccessorTable<WriteSet, WriteSet.Builder> InternalFieldAccessors { | ||
1994 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_WriteSet__FieldAccessorTable; } | ||
1995 | } | ||
1996 | |||
1997 | public const int WritesFieldNumber = 10; | ||
1998 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> writes_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
1999 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> WritesList { | ||
2000 | get { return writes_; } | ||
2001 | } | ||
2002 | public int WritesCount { | ||
2003 | get { return writes_.Count; } | ||
2004 | } | ||
2005 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { | ||
2006 | return writes_[index]; | ||
2007 | } | ||
2008 | |||
2009 | public override bool IsInitialized { | ||
2010 | get { | ||
2011 | return true; | ||
2012 | } | ||
2013 | } | ||
2014 | |||
2015 | public override void WriteTo(pb::CodedOutputStream output) { | ||
2016 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { | ||
2017 | output.WriteMessage(10, element); | ||
2018 | } | ||
2019 | UnknownFields.WriteTo(output); | ||
2020 | } | ||
2021 | |||
2022 | private int memoizedSerializedSize = -1; | ||
2023 | public override int SerializedSize { | ||
2024 | get { | ||
2025 | int size = memoizedSerializedSize; | ||
2026 | if (size != -1) return size; | ||
2027 | |||
2028 | size = 0; | ||
2029 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { | ||
2030 | size += pb::CodedOutputStream.ComputeMessageSize(10, element); | ||
2031 | } | ||
2032 | size += UnknownFields.SerializedSize; | ||
2033 | memoizedSerializedSize = size; | ||
2034 | return size; | ||
2035 | } | ||
2036 | } | ||
2037 | |||
2038 | public static WriteSet ParseFrom(pb::ByteString data) { | ||
2039 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2040 | } | ||
2041 | public static WriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
2042 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2043 | } | ||
2044 | public static WriteSet ParseFrom(byte[] data) { | ||
2045 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2046 | } | ||
2047 | public static WriteSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
2048 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2049 | } | ||
2050 | public static WriteSet ParseFrom(global::System.IO.Stream input) { | ||
2051 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2052 | } | ||
2053 | public static WriteSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2054 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2055 | } | ||
2056 | public static WriteSet ParseDelimitedFrom(global::System.IO.Stream input) { | ||
2057 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
2058 | } | ||
2059 | public static WriteSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2060 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
2061 | } | ||
2062 | public static WriteSet ParseFrom(pb::CodedInputStream input) { | ||
2063 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2064 | } | ||
2065 | public static WriteSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2066 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2067 | } | ||
2068 | public static Builder CreateBuilder() { return new Builder(); } | ||
2069 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
2070 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
2071 | public static Builder CreateBuilder(WriteSet prototype) { | ||
2072 | return (Builder) new Builder().MergeFrom(prototype); | ||
2073 | } | ||
2074 | |||
2075 | public sealed partial class Builder : pb::GeneratedBuilder<WriteSet, Builder> { | ||
2076 | protected override Builder ThisBuilder { | ||
2077 | get { return this; } | ||
2078 | } | ||
2079 | public Builder() {} | ||
2080 | |||
2081 | WriteSet result = new WriteSet(); | ||
2082 | |||
2083 | protected override WriteSet MessageBeingBuilt { | ||
2084 | get { return result; } | ||
2085 | } | ||
2086 | |||
2087 | public override Builder Clear() { | ||
2088 | result = new WriteSet(); | ||
2089 | return this; | ||
2090 | } | ||
2091 | |||
2092 | public override Builder Clone() { | ||
2093 | return new Builder().MergeFrom(result); | ||
2094 | } | ||
2095 | |||
2096 | public override pbd::MessageDescriptor DescriptorForType { | ||
2097 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.Descriptor; } | ||
2098 | } | ||
2099 | |||
2100 | public override WriteSet DefaultInstanceForType { | ||
2101 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.DefaultInstance; } | ||
2102 | } | ||
2103 | |||
2104 | public override WriteSet BuildPartial() { | ||
2105 | if (result == null) { | ||
2106 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
2107 | } | ||
2108 | result.writes_.MakeReadOnly(); | ||
2109 | WriteSet returnMe = result; | ||
2110 | result = null; | ||
2111 | return returnMe; | ||
2112 | } | ||
2113 | |||
2114 | public override Builder MergeFrom(pb::IMessage other) { | ||
2115 | if (other is WriteSet) { | ||
2116 | return MergeFrom((WriteSet) other); | ||
2117 | } else { | ||
2118 | base.MergeFrom(other); | ||
2119 | return this; | ||
2120 | } | ||
2121 | } | ||
2122 | |||
2123 | public override Builder MergeFrom(WriteSet other) { | ||
2124 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.WriteSet.DefaultInstance) return this; | ||
2125 | if (other.writes_.Count != 0) { | ||
2126 | base.AddRange(other.writes_, result.writes_); | ||
2127 | } | ||
2128 | this.MergeUnknownFields(other.UnknownFields); | ||
2129 | return this; | ||
2130 | } | ||
2131 | |||
2132 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
2133 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
2134 | } | ||
2135 | |||
2136 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2137 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
2138 | while (true) { | ||
2139 | uint tag = input.ReadTag(); | ||
2140 | switch (tag) { | ||
2141 | case 0: { | ||
2142 | if (unknownFields != null) { | ||
2143 | this.UnknownFields = unknownFields.Build(); | ||
2144 | } | ||
2145 | return this; | ||
2146 | } | ||
2147 | default: { | ||
2148 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
2149 | if (unknownFields != null) { | ||
2150 | this.UnknownFields = unknownFields.Build(); | ||
2151 | } | ||
2152 | return this; | ||
2153 | } | ||
2154 | if (unknownFields == null) { | ||
2155 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2156 | } | ||
2157 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
2158 | break; | ||
2159 | } | ||
2160 | case 82: { | ||
2161 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
2162 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2163 | AddWrites(subBuilder.BuildPartial()); | ||
2164 | break; | ||
2165 | } | ||
2166 | } | ||
2167 | } | ||
2168 | } | ||
2169 | |||
2170 | |||
2171 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> WritesList { | ||
2172 | get { return result.writes_; } | ||
2173 | } | ||
2174 | public int WritesCount { | ||
2175 | get { return result.WritesCount; } | ||
2176 | } | ||
2177 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { | ||
2178 | return result.GetWrites(index); | ||
2179 | } | ||
2180 | public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2181 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2182 | result.writes_[index] = value; | ||
2183 | return this; | ||
2184 | } | ||
2185 | public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2186 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2187 | result.writes_[index] = builderForValue.Build(); | ||
2188 | return this; | ||
2189 | } | ||
2190 | public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2191 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2192 | result.writes_.Add(value); | ||
2193 | return this; | ||
2194 | } | ||
2195 | public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2196 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2197 | result.writes_.Add(builderForValue.Build()); | ||
2198 | return this; | ||
2199 | } | ||
2200 | public Builder AddRangeWrites(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
2201 | base.AddRange(values, result.writes_); | ||
2202 | return this; | ||
2203 | } | ||
2204 | public Builder ClearWrites() { | ||
2205 | result.writes_.Clear(); | ||
2206 | return this; | ||
2207 | } | ||
2208 | } | ||
2209 | static WriteSet() { | ||
2210 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
2211 | } | ||
2212 | } | ||
2213 | |||
2214 | public sealed partial class ReadWriteSet : pb::GeneratedMessage<ReadWriteSet, ReadWriteSet.Builder> { | ||
2215 | private static readonly ReadWriteSet defaultInstance = new Builder().BuildPartial(); | ||
2216 | public static ReadWriteSet DefaultInstance { | ||
2217 | get { return defaultInstance; } | ||
2218 | } | ||
2219 | |||
2220 | public override ReadWriteSet DefaultInstanceForType { | ||
2221 | get { return defaultInstance; } | ||
2222 | } | ||
2223 | |||
2224 | protected override ReadWriteSet ThisMessage { | ||
2225 | get { return this; } | ||
2226 | } | ||
2227 | |||
2228 | public static pbd::MessageDescriptor Descriptor { | ||
2229 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__Descriptor; } | ||
2230 | } | ||
2231 | |||
2232 | protected override pb::FieldAccess.FieldAccessorTable<ReadWriteSet, ReadWriteSet.Builder> InternalFieldAccessors { | ||
2233 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_ReadWriteSet__FieldAccessorTable; } | ||
2234 | } | ||
2235 | |||
2236 | #region Nested types | ||
2237 | public static class Types { | ||
2238 | public enum ReadWriteSetOptions { | ||
2239 | RETURN_READ_NAMES = 1, | ||
2240 | } | ||
2241 | |||
2242 | } | ||
2243 | #endregion | ||
2244 | |||
2245 | public const int ReadsFieldNumber = 9; | ||
2246 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> reads_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
2247 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
2248 | get { return reads_; } | ||
2249 | } | ||
2250 | public int ReadsCount { | ||
2251 | get { return reads_.Count; } | ||
2252 | } | ||
2253 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
2254 | return reads_[index]; | ||
2255 | } | ||
2256 | |||
2257 | public const int WritesFieldNumber = 10; | ||
2258 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> writes_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
2259 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> WritesList { | ||
2260 | get { return writes_; } | ||
2261 | } | ||
2262 | public int WritesCount { | ||
2263 | get { return writes_.Count; } | ||
2264 | } | ||
2265 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { | ||
2266 | return writes_[index]; | ||
2267 | } | ||
2268 | |||
2269 | public const int OptionsFieldNumber = 14; | ||
2270 | private bool hasOptions; | ||
2271 | private ulong options_ = 0UL; | ||
2272 | public bool HasOptions { | ||
2273 | get { return hasOptions; } | ||
2274 | } | ||
2275 | [global::System.CLSCompliant(false)] | ||
2276 | public ulong Options { | ||
2277 | get { return options_; } | ||
2278 | } | ||
2279 | |||
2280 | public override bool IsInitialized { | ||
2281 | get { | ||
2282 | return true; | ||
2283 | } | ||
2284 | } | ||
2285 | |||
2286 | public override void WriteTo(pb::CodedOutputStream output) { | ||
2287 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
2288 | output.WriteMessage(9, element); | ||
2289 | } | ||
2290 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { | ||
2291 | output.WriteMessage(10, element); | ||
2292 | } | ||
2293 | if (HasOptions) { | ||
2294 | output.WriteUInt64(14, Options); | ||
2295 | } | ||
2296 | UnknownFields.WriteTo(output); | ||
2297 | } | ||
2298 | |||
2299 | private int memoizedSerializedSize = -1; | ||
2300 | public override int SerializedSize { | ||
2301 | get { | ||
2302 | int size = memoizedSerializedSize; | ||
2303 | if (size != -1) return size; | ||
2304 | |||
2305 | size = 0; | ||
2306 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
2307 | size += pb::CodedOutputStream.ComputeMessageSize(9, element); | ||
2308 | } | ||
2309 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { | ||
2310 | size += pb::CodedOutputStream.ComputeMessageSize(10, element); | ||
2311 | } | ||
2312 | if (HasOptions) { | ||
2313 | size += pb::CodedOutputStream.ComputeUInt64Size(14, Options); | ||
2314 | } | ||
2315 | size += UnknownFields.SerializedSize; | ||
2316 | memoizedSerializedSize = size; | ||
2317 | return size; | ||
2318 | } | ||
2319 | } | ||
2320 | |||
2321 | public static ReadWriteSet ParseFrom(pb::ByteString data) { | ||
2322 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2323 | } | ||
2324 | public static ReadWriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
2325 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2326 | } | ||
2327 | public static ReadWriteSet ParseFrom(byte[] data) { | ||
2328 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2329 | } | ||
2330 | public static ReadWriteSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
2331 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2332 | } | ||
2333 | public static ReadWriteSet ParseFrom(global::System.IO.Stream input) { | ||
2334 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2335 | } | ||
2336 | public static ReadWriteSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2337 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2338 | } | ||
2339 | public static ReadWriteSet ParseDelimitedFrom(global::System.IO.Stream input) { | ||
2340 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
2341 | } | ||
2342 | public static ReadWriteSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2343 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
2344 | } | ||
2345 | public static ReadWriteSet ParseFrom(pb::CodedInputStream input) { | ||
2346 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2347 | } | ||
2348 | public static ReadWriteSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2349 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2350 | } | ||
2351 | public static Builder CreateBuilder() { return new Builder(); } | ||
2352 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
2353 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
2354 | public static Builder CreateBuilder(ReadWriteSet prototype) { | ||
2355 | return (Builder) new Builder().MergeFrom(prototype); | ||
2356 | } | ||
2357 | |||
2358 | public sealed partial class Builder : pb::GeneratedBuilder<ReadWriteSet, Builder> { | ||
2359 | protected override Builder ThisBuilder { | ||
2360 | get { return this; } | ||
2361 | } | ||
2362 | public Builder() {} | ||
2363 | |||
2364 | ReadWriteSet result = new ReadWriteSet(); | ||
2365 | |||
2366 | protected override ReadWriteSet MessageBeingBuilt { | ||
2367 | get { return result; } | ||
2368 | } | ||
2369 | |||
2370 | public override Builder Clear() { | ||
2371 | result = new ReadWriteSet(); | ||
2372 | return this; | ||
2373 | } | ||
2374 | |||
2375 | public override Builder Clone() { | ||
2376 | return new Builder().MergeFrom(result); | ||
2377 | } | ||
2378 | |||
2379 | public override pbd::MessageDescriptor DescriptorForType { | ||
2380 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.Descriptor; } | ||
2381 | } | ||
2382 | |||
2383 | public override ReadWriteSet DefaultInstanceForType { | ||
2384 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.DefaultInstance; } | ||
2385 | } | ||
2386 | |||
2387 | public override ReadWriteSet BuildPartial() { | ||
2388 | if (result == null) { | ||
2389 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
2390 | } | ||
2391 | result.reads_.MakeReadOnly(); | ||
2392 | result.writes_.MakeReadOnly(); | ||
2393 | ReadWriteSet returnMe = result; | ||
2394 | result = null; | ||
2395 | return returnMe; | ||
2396 | } | ||
2397 | |||
2398 | public override Builder MergeFrom(pb::IMessage other) { | ||
2399 | if (other is ReadWriteSet) { | ||
2400 | return MergeFrom((ReadWriteSet) other); | ||
2401 | } else { | ||
2402 | base.MergeFrom(other); | ||
2403 | return this; | ||
2404 | } | ||
2405 | } | ||
2406 | |||
2407 | public override Builder MergeFrom(ReadWriteSet other) { | ||
2408 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.ReadWriteSet.DefaultInstance) return this; | ||
2409 | if (other.reads_.Count != 0) { | ||
2410 | base.AddRange(other.reads_, result.reads_); | ||
2411 | } | ||
2412 | if (other.writes_.Count != 0) { | ||
2413 | base.AddRange(other.writes_, result.writes_); | ||
2414 | } | ||
2415 | if (other.HasOptions) { | ||
2416 | Options = other.Options; | ||
2417 | } | ||
2418 | this.MergeUnknownFields(other.UnknownFields); | ||
2419 | return this; | ||
2420 | } | ||
2421 | |||
2422 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
2423 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
2424 | } | ||
2425 | |||
2426 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2427 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
2428 | while (true) { | ||
2429 | uint tag = input.ReadTag(); | ||
2430 | switch (tag) { | ||
2431 | case 0: { | ||
2432 | if (unknownFields != null) { | ||
2433 | this.UnknownFields = unknownFields.Build(); | ||
2434 | } | ||
2435 | return this; | ||
2436 | } | ||
2437 | default: { | ||
2438 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
2439 | if (unknownFields != null) { | ||
2440 | this.UnknownFields = unknownFields.Build(); | ||
2441 | } | ||
2442 | return this; | ||
2443 | } | ||
2444 | if (unknownFields == null) { | ||
2445 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2446 | } | ||
2447 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
2448 | break; | ||
2449 | } | ||
2450 | case 74: { | ||
2451 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
2452 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2453 | AddReads(subBuilder.BuildPartial()); | ||
2454 | break; | ||
2455 | } | ||
2456 | case 82: { | ||
2457 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
2458 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2459 | AddWrites(subBuilder.BuildPartial()); | ||
2460 | break; | ||
2461 | } | ||
2462 | case 112: { | ||
2463 | Options = input.ReadUInt64(); | ||
2464 | break; | ||
2465 | } | ||
2466 | } | ||
2467 | } | ||
2468 | } | ||
2469 | |||
2470 | |||
2471 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
2472 | get { return result.reads_; } | ||
2473 | } | ||
2474 | public int ReadsCount { | ||
2475 | get { return result.ReadsCount; } | ||
2476 | } | ||
2477 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
2478 | return result.GetReads(index); | ||
2479 | } | ||
2480 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2481 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2482 | result.reads_[index] = value; | ||
2483 | return this; | ||
2484 | } | ||
2485 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2486 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2487 | result.reads_[index] = builderForValue.Build(); | ||
2488 | return this; | ||
2489 | } | ||
2490 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2491 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2492 | result.reads_.Add(value); | ||
2493 | return this; | ||
2494 | } | ||
2495 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2496 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2497 | result.reads_.Add(builderForValue.Build()); | ||
2498 | return this; | ||
2499 | } | ||
2500 | public Builder AddRangeReads(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
2501 | base.AddRange(values, result.reads_); | ||
2502 | return this; | ||
2503 | } | ||
2504 | public Builder ClearReads() { | ||
2505 | result.reads_.Clear(); | ||
2506 | return this; | ||
2507 | } | ||
2508 | |||
2509 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> WritesList { | ||
2510 | get { return result.writes_; } | ||
2511 | } | ||
2512 | public int WritesCount { | ||
2513 | get { return result.WritesCount; } | ||
2514 | } | ||
2515 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { | ||
2516 | return result.GetWrites(index); | ||
2517 | } | ||
2518 | public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2519 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2520 | result.writes_[index] = value; | ||
2521 | return this; | ||
2522 | } | ||
2523 | public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2524 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2525 | result.writes_[index] = builderForValue.Build(); | ||
2526 | return this; | ||
2527 | } | ||
2528 | public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2529 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2530 | result.writes_.Add(value); | ||
2531 | return this; | ||
2532 | } | ||
2533 | public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2534 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2535 | result.writes_.Add(builderForValue.Build()); | ||
2536 | return this; | ||
2537 | } | ||
2538 | public Builder AddRangeWrites(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
2539 | base.AddRange(values, result.writes_); | ||
2540 | return this; | ||
2541 | } | ||
2542 | public Builder ClearWrites() { | ||
2543 | result.writes_.Clear(); | ||
2544 | return this; | ||
2545 | } | ||
2546 | |||
2547 | public bool HasOptions { | ||
2548 | get { return result.HasOptions; } | ||
2549 | } | ||
2550 | [global::System.CLSCompliant(false)] | ||
2551 | public ulong Options { | ||
2552 | get { return result.Options; } | ||
2553 | set { SetOptions(value); } | ||
2554 | } | ||
2555 | [global::System.CLSCompliant(false)] | ||
2556 | public Builder SetOptions(ulong value) { | ||
2557 | result.hasOptions = true; | ||
2558 | result.options_ = value; | ||
2559 | return this; | ||
2560 | } | ||
2561 | public Builder ClearOptions() { | ||
2562 | result.hasOptions = false; | ||
2563 | result.options_ = 0UL; | ||
2564 | return this; | ||
2565 | } | ||
2566 | } | ||
2567 | static ReadWriteSet() { | ||
2568 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
2569 | } | ||
2570 | } | ||
2571 | |||
2572 | public sealed partial class Minitransaction : pb::GeneratedMessage<Minitransaction, Minitransaction.Builder> { | ||
2573 | private static readonly Minitransaction defaultInstance = new Builder().BuildPartial(); | ||
2574 | public static Minitransaction DefaultInstance { | ||
2575 | get { return defaultInstance; } | ||
2576 | } | ||
2577 | |||
2578 | public override Minitransaction DefaultInstanceForType { | ||
2579 | get { return defaultInstance; } | ||
2580 | } | ||
2581 | |||
2582 | protected override Minitransaction ThisMessage { | ||
2583 | get { return this; } | ||
2584 | } | ||
2585 | |||
2586 | public static pbd::MessageDescriptor Descriptor { | ||
2587 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__Descriptor; } | ||
2588 | } | ||
2589 | |||
2590 | protected override pb::FieldAccess.FieldAccessorTable<Minitransaction, Minitransaction.Builder> InternalFieldAccessors { | ||
2591 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Minitransaction__FieldAccessorTable; } | ||
2592 | } | ||
2593 | |||
2594 | #region Nested types | ||
2595 | public static class Types { | ||
2596 | public enum TransactionOptions { | ||
2597 | RETURN_READ_NAMES = 1, | ||
2598 | } | ||
2599 | |||
2600 | } | ||
2601 | #endregion | ||
2602 | |||
2603 | public const int ReadsFieldNumber = 9; | ||
2604 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> reads_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
2605 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
2606 | get { return reads_; } | ||
2607 | } | ||
2608 | public int ReadsCount { | ||
2609 | get { return reads_.Count; } | ||
2610 | } | ||
2611 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
2612 | return reads_[index]; | ||
2613 | } | ||
2614 | |||
2615 | public const int WritesFieldNumber = 10; | ||
2616 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> writes_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
2617 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> WritesList { | ||
2618 | get { return writes_; } | ||
2619 | } | ||
2620 | public int WritesCount { | ||
2621 | get { return writes_.Count; } | ||
2622 | } | ||
2623 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { | ||
2624 | return writes_[index]; | ||
2625 | } | ||
2626 | |||
2627 | public const int ComparesFieldNumber = 11; | ||
2628 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement> compares_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement>(); | ||
2629 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement> ComparesList { | ||
2630 | get { return compares_; } | ||
2631 | } | ||
2632 | public int ComparesCount { | ||
2633 | get { return compares_.Count; } | ||
2634 | } | ||
2635 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement GetCompares(int index) { | ||
2636 | return compares_[index]; | ||
2637 | } | ||
2638 | |||
2639 | public const int OptionsFieldNumber = 14; | ||
2640 | private bool hasOptions; | ||
2641 | private ulong options_ = 0UL; | ||
2642 | public bool HasOptions { | ||
2643 | get { return hasOptions; } | ||
2644 | } | ||
2645 | [global::System.CLSCompliant(false)] | ||
2646 | public ulong Options { | ||
2647 | get { return options_; } | ||
2648 | } | ||
2649 | |||
2650 | public override bool IsInitialized { | ||
2651 | get { | ||
2652 | return true; | ||
2653 | } | ||
2654 | } | ||
2655 | |||
2656 | public override void WriteTo(pb::CodedOutputStream output) { | ||
2657 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
2658 | output.WriteMessage(9, element); | ||
2659 | } | ||
2660 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { | ||
2661 | output.WriteMessage(10, element); | ||
2662 | } | ||
2663 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement element in ComparesList) { | ||
2664 | output.WriteMessage(11, element); | ||
2665 | } | ||
2666 | if (HasOptions) { | ||
2667 | output.WriteUInt64(14, Options); | ||
2668 | } | ||
2669 | UnknownFields.WriteTo(output); | ||
2670 | } | ||
2671 | |||
2672 | private int memoizedSerializedSize = -1; | ||
2673 | public override int SerializedSize { | ||
2674 | get { | ||
2675 | int size = memoizedSerializedSize; | ||
2676 | if (size != -1) return size; | ||
2677 | |||
2678 | size = 0; | ||
2679 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
2680 | size += pb::CodedOutputStream.ComputeMessageSize(9, element); | ||
2681 | } | ||
2682 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in WritesList) { | ||
2683 | size += pb::CodedOutputStream.ComputeMessageSize(10, element); | ||
2684 | } | ||
2685 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement element in ComparesList) { | ||
2686 | size += pb::CodedOutputStream.ComputeMessageSize(11, element); | ||
2687 | } | ||
2688 | if (HasOptions) { | ||
2689 | size += pb::CodedOutputStream.ComputeUInt64Size(14, Options); | ||
2690 | } | ||
2691 | size += UnknownFields.SerializedSize; | ||
2692 | memoizedSerializedSize = size; | ||
2693 | return size; | ||
2694 | } | ||
2695 | } | ||
2696 | |||
2697 | public static Minitransaction ParseFrom(pb::ByteString data) { | ||
2698 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2699 | } | ||
2700 | public static Minitransaction ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
2701 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2702 | } | ||
2703 | public static Minitransaction ParseFrom(byte[] data) { | ||
2704 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2705 | } | ||
2706 | public static Minitransaction ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
2707 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2708 | } | ||
2709 | public static Minitransaction ParseFrom(global::System.IO.Stream input) { | ||
2710 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2711 | } | ||
2712 | public static Minitransaction ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2713 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2714 | } | ||
2715 | public static Minitransaction ParseDelimitedFrom(global::System.IO.Stream input) { | ||
2716 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
2717 | } | ||
2718 | public static Minitransaction ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2719 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
2720 | } | ||
2721 | public static Minitransaction ParseFrom(pb::CodedInputStream input) { | ||
2722 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2723 | } | ||
2724 | public static Minitransaction ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2725 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2726 | } | ||
2727 | public static Builder CreateBuilder() { return new Builder(); } | ||
2728 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
2729 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
2730 | public static Builder CreateBuilder(Minitransaction prototype) { | ||
2731 | return (Builder) new Builder().MergeFrom(prototype); | ||
2732 | } | ||
2733 | |||
2734 | public sealed partial class Builder : pb::GeneratedBuilder<Minitransaction, Builder> { | ||
2735 | protected override Builder ThisBuilder { | ||
2736 | get { return this; } | ||
2737 | } | ||
2738 | public Builder() {} | ||
2739 | |||
2740 | Minitransaction result = new Minitransaction(); | ||
2741 | |||
2742 | protected override Minitransaction MessageBeingBuilt { | ||
2743 | get { return result; } | ||
2744 | } | ||
2745 | |||
2746 | public override Builder Clear() { | ||
2747 | result = new Minitransaction(); | ||
2748 | return this; | ||
2749 | } | ||
2750 | |||
2751 | public override Builder Clone() { | ||
2752 | return new Builder().MergeFrom(result); | ||
2753 | } | ||
2754 | |||
2755 | public override pbd::MessageDescriptor DescriptorForType { | ||
2756 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.Descriptor; } | ||
2757 | } | ||
2758 | |||
2759 | public override Minitransaction DefaultInstanceForType { | ||
2760 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.DefaultInstance; } | ||
2761 | } | ||
2762 | |||
2763 | public override Minitransaction BuildPartial() { | ||
2764 | if (result == null) { | ||
2765 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
2766 | } | ||
2767 | result.reads_.MakeReadOnly(); | ||
2768 | result.writes_.MakeReadOnly(); | ||
2769 | result.compares_.MakeReadOnly(); | ||
2770 | Minitransaction returnMe = result; | ||
2771 | result = null; | ||
2772 | return returnMe; | ||
2773 | } | ||
2774 | |||
2775 | public override Builder MergeFrom(pb::IMessage other) { | ||
2776 | if (other is Minitransaction) { | ||
2777 | return MergeFrom((Minitransaction) other); | ||
2778 | } else { | ||
2779 | base.MergeFrom(other); | ||
2780 | return this; | ||
2781 | } | ||
2782 | } | ||
2783 | |||
2784 | public override Builder MergeFrom(Minitransaction other) { | ||
2785 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.Minitransaction.DefaultInstance) return this; | ||
2786 | if (other.reads_.Count != 0) { | ||
2787 | base.AddRange(other.reads_, result.reads_); | ||
2788 | } | ||
2789 | if (other.writes_.Count != 0) { | ||
2790 | base.AddRange(other.writes_, result.writes_); | ||
2791 | } | ||
2792 | if (other.compares_.Count != 0) { | ||
2793 | base.AddRange(other.compares_, result.compares_); | ||
2794 | } | ||
2795 | if (other.HasOptions) { | ||
2796 | Options = other.Options; | ||
2797 | } | ||
2798 | this.MergeUnknownFields(other.UnknownFields); | ||
2799 | return this; | ||
2800 | } | ||
2801 | |||
2802 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
2803 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
2804 | } | ||
2805 | |||
2806 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2807 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
2808 | while (true) { | ||
2809 | uint tag = input.ReadTag(); | ||
2810 | switch (tag) { | ||
2811 | case 0: { | ||
2812 | if (unknownFields != null) { | ||
2813 | this.UnknownFields = unknownFields.Build(); | ||
2814 | } | ||
2815 | return this; | ||
2816 | } | ||
2817 | default: { | ||
2818 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
2819 | if (unknownFields != null) { | ||
2820 | this.UnknownFields = unknownFields.Build(); | ||
2821 | } | ||
2822 | return this; | ||
2823 | } | ||
2824 | if (unknownFields == null) { | ||
2825 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2826 | } | ||
2827 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
2828 | break; | ||
2829 | } | ||
2830 | case 74: { | ||
2831 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
2832 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2833 | AddReads(subBuilder.BuildPartial()); | ||
2834 | break; | ||
2835 | } | ||
2836 | case 82: { | ||
2837 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
2838 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2839 | AddWrites(subBuilder.BuildPartial()); | ||
2840 | break; | ||
2841 | } | ||
2842 | case 90: { | ||
2843 | global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.CreateBuilder(); | ||
2844 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2845 | AddCompares(subBuilder.BuildPartial()); | ||
2846 | break; | ||
2847 | } | ||
2848 | case 112: { | ||
2849 | Options = input.ReadUInt64(); | ||
2850 | break; | ||
2851 | } | ||
2852 | } | ||
2853 | } | ||
2854 | } | ||
2855 | |||
2856 | |||
2857 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
2858 | get { return result.reads_; } | ||
2859 | } | ||
2860 | public int ReadsCount { | ||
2861 | get { return result.ReadsCount; } | ||
2862 | } | ||
2863 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
2864 | return result.GetReads(index); | ||
2865 | } | ||
2866 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2867 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2868 | result.reads_[index] = value; | ||
2869 | return this; | ||
2870 | } | ||
2871 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2872 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2873 | result.reads_[index] = builderForValue.Build(); | ||
2874 | return this; | ||
2875 | } | ||
2876 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2877 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2878 | result.reads_.Add(value); | ||
2879 | return this; | ||
2880 | } | ||
2881 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2882 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2883 | result.reads_.Add(builderForValue.Build()); | ||
2884 | return this; | ||
2885 | } | ||
2886 | public Builder AddRangeReads(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
2887 | base.AddRange(values, result.reads_); | ||
2888 | return this; | ||
2889 | } | ||
2890 | public Builder ClearReads() { | ||
2891 | result.reads_.Clear(); | ||
2892 | return this; | ||
2893 | } | ||
2894 | |||
2895 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> WritesList { | ||
2896 | get { return result.writes_; } | ||
2897 | } | ||
2898 | public int WritesCount { | ||
2899 | get { return result.WritesCount; } | ||
2900 | } | ||
2901 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetWrites(int index) { | ||
2902 | return result.GetWrites(index); | ||
2903 | } | ||
2904 | public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2905 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2906 | result.writes_[index] = value; | ||
2907 | return this; | ||
2908 | } | ||
2909 | public Builder SetWrites(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2910 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2911 | result.writes_[index] = builderForValue.Build(); | ||
2912 | return this; | ||
2913 | } | ||
2914 | public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
2915 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2916 | result.writes_.Add(value); | ||
2917 | return this; | ||
2918 | } | ||
2919 | public Builder AddWrites(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
2920 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2921 | result.writes_.Add(builderForValue.Build()); | ||
2922 | return this; | ||
2923 | } | ||
2924 | public Builder AddRangeWrites(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
2925 | base.AddRange(values, result.writes_); | ||
2926 | return this; | ||
2927 | } | ||
2928 | public Builder ClearWrites() { | ||
2929 | result.writes_.Clear(); | ||
2930 | return this; | ||
2931 | } | ||
2932 | |||
2933 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement> ComparesList { | ||
2934 | get { return result.compares_; } | ||
2935 | } | ||
2936 | public int ComparesCount { | ||
2937 | get { return result.ComparesCount; } | ||
2938 | } | ||
2939 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement GetCompares(int index) { | ||
2940 | return result.GetCompares(index); | ||
2941 | } | ||
2942 | public Builder SetCompares(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement value) { | ||
2943 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2944 | result.compares_[index] = value; | ||
2945 | return this; | ||
2946 | } | ||
2947 | public Builder SetCompares(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder builderForValue) { | ||
2948 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2949 | result.compares_[index] = builderForValue.Build(); | ||
2950 | return this; | ||
2951 | } | ||
2952 | public Builder AddCompares(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement value) { | ||
2953 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2954 | result.compares_.Add(value); | ||
2955 | return this; | ||
2956 | } | ||
2957 | public Builder AddCompares(global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement.Builder builderForValue) { | ||
2958 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2959 | result.compares_.Add(builderForValue.Build()); | ||
2960 | return this; | ||
2961 | } | ||
2962 | public Builder AddRangeCompares(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.CompareElement> values) { | ||
2963 | base.AddRange(values, result.compares_); | ||
2964 | return this; | ||
2965 | } | ||
2966 | public Builder ClearCompares() { | ||
2967 | result.compares_.Clear(); | ||
2968 | return this; | ||
2969 | } | ||
2970 | |||
2971 | public bool HasOptions { | ||
2972 | get { return result.HasOptions; } | ||
2973 | } | ||
2974 | [global::System.CLSCompliant(false)] | ||
2975 | public ulong Options { | ||
2976 | get { return result.Options; } | ||
2977 | set { SetOptions(value); } | ||
2978 | } | ||
2979 | [global::System.CLSCompliant(false)] | ||
2980 | public Builder SetOptions(ulong value) { | ||
2981 | result.hasOptions = true; | ||
2982 | result.options_ = value; | ||
2983 | return this; | ||
2984 | } | ||
2985 | public Builder ClearOptions() { | ||
2986 | result.hasOptions = false; | ||
2987 | result.options_ = 0UL; | ||
2988 | return this; | ||
2989 | } | ||
2990 | } | ||
2991 | static Minitransaction() { | ||
2992 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
2993 | } | ||
2994 | } | ||
2995 | |||
2996 | public sealed partial class Response : pb::GeneratedMessage<Response, Response.Builder> { | ||
2997 | private static readonly Response defaultInstance = new Builder().BuildPartial(); | ||
2998 | public static Response DefaultInstance { | ||
2999 | get { return defaultInstance; } | ||
3000 | } | ||
3001 | |||
3002 | public override Response DefaultInstanceForType { | ||
3003 | get { return defaultInstance; } | ||
3004 | } | ||
3005 | |||
3006 | protected override Response ThisMessage { | ||
3007 | get { return this; } | ||
3008 | } | ||
3009 | |||
3010 | public static pbd::MessageDescriptor Descriptor { | ||
3011 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__Descriptor; } | ||
3012 | } | ||
3013 | |||
3014 | protected override pb::FieldAccess.FieldAccessorTable<Response, Response.Builder> InternalFieldAccessors { | ||
3015 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.internal__static_Sirikata_Persistence_Protocol__PBJ_Internal_Response__FieldAccessorTable; } | ||
3016 | } | ||
3017 | |||
3018 | #region Nested types | ||
3019 | public static class Types { | ||
3020 | public enum ReturnStatus { | ||
3021 | SUCCESS = 0, | ||
3022 | DATABASE_LOCKED = 3, | ||
3023 | KEY_MISSING = 4, | ||
3024 | COMPARISON_FAILED = 5, | ||
3025 | INTERNAL_ERROR = 6, | ||
3026 | } | ||
3027 | |||
3028 | } | ||
3029 | #endregion | ||
3030 | |||
3031 | public const int ReadsFieldNumber = 9; | ||
3032 | private pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> reads_ = new pbc::PopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement>(); | ||
3033 | public scg::IList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
3034 | get { return reads_; } | ||
3035 | } | ||
3036 | public int ReadsCount { | ||
3037 | get { return reads_.Count; } | ||
3038 | } | ||
3039 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
3040 | return reads_[index]; | ||
3041 | } | ||
3042 | |||
3043 | public const int ReturnStatusFieldNumber = 15; | ||
3044 | private bool hasReturnStatus; | ||
3045 | private global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus.SUCCESS; | ||
3046 | public bool HasReturnStatus { | ||
3047 | get { return hasReturnStatus; } | ||
3048 | } | ||
3049 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus ReturnStatus { | ||
3050 | get { return returnStatus_; } | ||
3051 | } | ||
3052 | |||
3053 | public override bool IsInitialized { | ||
3054 | get { | ||
3055 | return true; | ||
3056 | } | ||
3057 | } | ||
3058 | |||
3059 | public override void WriteTo(pb::CodedOutputStream output) { | ||
3060 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
3061 | output.WriteMessage(9, element); | ||
3062 | } | ||
3063 | if (HasReturnStatus) { | ||
3064 | output.WriteEnum(15, (int) ReturnStatus); | ||
3065 | } | ||
3066 | UnknownFields.WriteTo(output); | ||
3067 | } | ||
3068 | |||
3069 | private int memoizedSerializedSize = -1; | ||
3070 | public override int SerializedSize { | ||
3071 | get { | ||
3072 | int size = memoizedSerializedSize; | ||
3073 | if (size != -1) return size; | ||
3074 | |||
3075 | size = 0; | ||
3076 | foreach (global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement element in ReadsList) { | ||
3077 | size += pb::CodedOutputStream.ComputeMessageSize(9, element); | ||
3078 | } | ||
3079 | if (HasReturnStatus) { | ||
3080 | size += pb::CodedOutputStream.ComputeEnumSize(15, (int) ReturnStatus); | ||
3081 | } | ||
3082 | size += UnknownFields.SerializedSize; | ||
3083 | memoizedSerializedSize = size; | ||
3084 | return size; | ||
3085 | } | ||
3086 | } | ||
3087 | |||
3088 | public static Response ParseFrom(pb::ByteString data) { | ||
3089 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3090 | } | ||
3091 | public static Response ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
3092 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3093 | } | ||
3094 | public static Response ParseFrom(byte[] data) { | ||
3095 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3096 | } | ||
3097 | public static Response ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
3098 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3099 | } | ||
3100 | public static Response ParseFrom(global::System.IO.Stream input) { | ||
3101 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3102 | } | ||
3103 | public static Response ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3104 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3105 | } | ||
3106 | public static Response ParseDelimitedFrom(global::System.IO.Stream input) { | ||
3107 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
3108 | } | ||
3109 | public static Response ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3110 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
3111 | } | ||
3112 | public static Response ParseFrom(pb::CodedInputStream input) { | ||
3113 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3114 | } | ||
3115 | public static Response ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3116 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3117 | } | ||
3118 | public static Builder CreateBuilder() { return new Builder(); } | ||
3119 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
3120 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
3121 | public static Builder CreateBuilder(Response prototype) { | ||
3122 | return (Builder) new Builder().MergeFrom(prototype); | ||
3123 | } | ||
3124 | |||
3125 | public sealed partial class Builder : pb::GeneratedBuilder<Response, Builder> { | ||
3126 | protected override Builder ThisBuilder { | ||
3127 | get { return this; } | ||
3128 | } | ||
3129 | public Builder() {} | ||
3130 | |||
3131 | Response result = new Response(); | ||
3132 | |||
3133 | protected override Response MessageBeingBuilt { | ||
3134 | get { return result; } | ||
3135 | } | ||
3136 | |||
3137 | public override Builder Clear() { | ||
3138 | result = new Response(); | ||
3139 | return this; | ||
3140 | } | ||
3141 | |||
3142 | public override Builder Clone() { | ||
3143 | return new Builder().MergeFrom(result); | ||
3144 | } | ||
3145 | |||
3146 | public override pbd::MessageDescriptor DescriptorForType { | ||
3147 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Descriptor; } | ||
3148 | } | ||
3149 | |||
3150 | public override Response DefaultInstanceForType { | ||
3151 | get { return global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.DefaultInstance; } | ||
3152 | } | ||
3153 | |||
3154 | public override Response BuildPartial() { | ||
3155 | if (result == null) { | ||
3156 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
3157 | } | ||
3158 | result.reads_.MakeReadOnly(); | ||
3159 | Response returnMe = result; | ||
3160 | result = null; | ||
3161 | return returnMe; | ||
3162 | } | ||
3163 | |||
3164 | public override Builder MergeFrom(pb::IMessage other) { | ||
3165 | if (other is Response) { | ||
3166 | return MergeFrom((Response) other); | ||
3167 | } else { | ||
3168 | base.MergeFrom(other); | ||
3169 | return this; | ||
3170 | } | ||
3171 | } | ||
3172 | |||
3173 | public override Builder MergeFrom(Response other) { | ||
3174 | if (other == global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.DefaultInstance) return this; | ||
3175 | if (other.reads_.Count != 0) { | ||
3176 | base.AddRange(other.reads_, result.reads_); | ||
3177 | } | ||
3178 | if (other.HasReturnStatus) { | ||
3179 | ReturnStatus = other.ReturnStatus; | ||
3180 | } | ||
3181 | this.MergeUnknownFields(other.UnknownFields); | ||
3182 | return this; | ||
3183 | } | ||
3184 | |||
3185 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
3186 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
3187 | } | ||
3188 | |||
3189 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3190 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
3191 | while (true) { | ||
3192 | uint tag = input.ReadTag(); | ||
3193 | switch (tag) { | ||
3194 | case 0: { | ||
3195 | if (unknownFields != null) { | ||
3196 | this.UnknownFields = unknownFields.Build(); | ||
3197 | } | ||
3198 | return this; | ||
3199 | } | ||
3200 | default: { | ||
3201 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
3202 | if (unknownFields != null) { | ||
3203 | this.UnknownFields = unknownFields.Build(); | ||
3204 | } | ||
3205 | return this; | ||
3206 | } | ||
3207 | if (unknownFields == null) { | ||
3208 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
3209 | } | ||
3210 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
3211 | break; | ||
3212 | } | ||
3213 | case 74: { | ||
3214 | global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder subBuilder = global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.CreateBuilder(); | ||
3215 | input.ReadMessage(subBuilder, extensionRegistry); | ||
3216 | AddReads(subBuilder.BuildPartial()); | ||
3217 | break; | ||
3218 | } | ||
3219 | case 120: { | ||
3220 | int rawValue = input.ReadEnum(); | ||
3221 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus), rawValue)) { | ||
3222 | if (unknownFields == null) { | ||
3223 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
3224 | } | ||
3225 | unknownFields.MergeVarintField(15, (ulong) rawValue); | ||
3226 | } else { | ||
3227 | ReturnStatus = (global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus) rawValue; | ||
3228 | } | ||
3229 | break; | ||
3230 | } | ||
3231 | } | ||
3232 | } | ||
3233 | } | ||
3234 | |||
3235 | |||
3236 | public pbc::IPopsicleList<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> ReadsList { | ||
3237 | get { return result.reads_; } | ||
3238 | } | ||
3239 | public int ReadsCount { | ||
3240 | get { return result.ReadsCount; } | ||
3241 | } | ||
3242 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement GetReads(int index) { | ||
3243 | return result.GetReads(index); | ||
3244 | } | ||
3245 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
3246 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3247 | result.reads_[index] = value; | ||
3248 | return this; | ||
3249 | } | ||
3250 | public Builder SetReads(int index, global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
3251 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3252 | result.reads_[index] = builderForValue.Build(); | ||
3253 | return this; | ||
3254 | } | ||
3255 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement value) { | ||
3256 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3257 | result.reads_.Add(value); | ||
3258 | return this; | ||
3259 | } | ||
3260 | public Builder AddReads(global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement.Builder builderForValue) { | ||
3261 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3262 | result.reads_.Add(builderForValue.Build()); | ||
3263 | return this; | ||
3264 | } | ||
3265 | public Builder AddRangeReads(scg::IEnumerable<global::Sirikata.Persistence.Protocol._PBJ_Internal.StorageElement> values) { | ||
3266 | base.AddRange(values, result.reads_); | ||
3267 | return this; | ||
3268 | } | ||
3269 | public Builder ClearReads() { | ||
3270 | result.reads_.Clear(); | ||
3271 | return this; | ||
3272 | } | ||
3273 | |||
3274 | public bool HasReturnStatus { | ||
3275 | get { return result.HasReturnStatus; } | ||
3276 | } | ||
3277 | public global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus ReturnStatus { | ||
3278 | get { return result.ReturnStatus; } | ||
3279 | set { SetReturnStatus(value); } | ||
3280 | } | ||
3281 | public Builder SetReturnStatus(global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus value) { | ||
3282 | result.hasReturnStatus = true; | ||
3283 | result.returnStatus_ = value; | ||
3284 | return this; | ||
3285 | } | ||
3286 | public Builder ClearReturnStatus() { | ||
3287 | result.hasReturnStatus = false; | ||
3288 | result.returnStatus_ = global::Sirikata.Persistence.Protocol._PBJ_Internal.Response.Types.ReturnStatus.SUCCESS; | ||
3289 | return this; | ||
3290 | } | ||
3291 | } | ||
3292 | static Response() { | ||
3293 | object.ReferenceEquals(global::Sirikata.Persistence.Protocol._PBJ_Internal.Persistence.Descriptor, null); | ||
3294 | } | ||
3295 | } | ||
3296 | |||
3297 | #endregion | ||
3298 | |||
3299 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs deleted file mode 100644 index 196b0b9..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs +++ /dev/null | |||
@@ -1,1543 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace Sirikata.Persistence.Protocol { | ||
31 | public class StorageKey : PBJ.IMessage { | ||
32 | protected _PBJ_Internal.StorageKey super; | ||
33 | public _PBJ_Internal.StorageKey _PBJSuper{ get { return super;} } | ||
34 | public StorageKey() { | ||
35 | super=new _PBJ_Internal.StorageKey(); | ||
36 | } | ||
37 | public StorageKey(_PBJ_Internal.StorageKey reference) { | ||
38 | super=reference; | ||
39 | } | ||
40 | public static StorageKey defaultInstance= new StorageKey (_PBJ_Internal.StorageKey.DefaultInstance); | ||
41 | public static StorageKey DefaultInstance{ | ||
42 | get {return defaultInstance;} | ||
43 | } | ||
44 | public static pbd.MessageDescriptor Descriptor { | ||
45 | get { return _PBJ_Internal.StorageKey.Descriptor; } } | ||
46 | public static class Types { | ||
47 | } | ||
48 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
49 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
50 | } | ||
51 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
52 | return false; | ||
53 | } | ||
54 | public const int ObjectUuidFieldTag=9; | ||
55 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
56 | public PBJ.UUID ObjectUuid{ get { | ||
57 | if (HasObjectUuid) { | ||
58 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
59 | } else { | ||
60 | return PBJ._PBJ.CastUuid(); | ||
61 | } | ||
62 | } | ||
63 | } | ||
64 | public const int FieldIdFieldTag=10; | ||
65 | public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } | ||
66 | public ulong FieldId{ get { | ||
67 | if (HasFieldId) { | ||
68 | return PBJ._PBJ.CastUint64(super.FieldId); | ||
69 | } else { | ||
70 | return PBJ._PBJ.CastUint64(); | ||
71 | } | ||
72 | } | ||
73 | } | ||
74 | public const int FieldNameFieldTag=11; | ||
75 | public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } | ||
76 | public string FieldName{ get { | ||
77 | if (HasFieldName) { | ||
78 | return PBJ._PBJ.CastString(super.FieldName); | ||
79 | } else { | ||
80 | return PBJ._PBJ.CastString(); | ||
81 | } | ||
82 | } | ||
83 | } | ||
84 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
85 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
86 | public static Builder CreateBuilder() { return new Builder(); } | ||
87 | public static Builder CreateBuilder(StorageKey prototype) { | ||
88 | return (Builder)new Builder().MergeFrom(prototype); | ||
89 | } | ||
90 | public static StorageKey ParseFrom(pb::ByteString data) { | ||
91 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); | ||
92 | } | ||
93 | public static StorageKey ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
94 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); | ||
95 | } | ||
96 | public static StorageKey ParseFrom(byte[] data) { | ||
97 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); | ||
98 | } | ||
99 | public static StorageKey ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
100 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); | ||
101 | } | ||
102 | public static StorageKey ParseFrom(global::System.IO.Stream data) { | ||
103 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); | ||
104 | } | ||
105 | public static StorageKey ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
106 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); | ||
107 | } | ||
108 | public static StorageKey ParseFrom(pb::CodedInputStream data) { | ||
109 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data)); | ||
110 | } | ||
111 | public static StorageKey ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
112 | return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er)); | ||
113 | } | ||
114 | protected override bool _HasAllPBJFields{ get { | ||
115 | return true | ||
116 | ; | ||
117 | } } | ||
118 | public bool IsInitialized { get { | ||
119 | return super.IsInitialized&&_HasAllPBJFields; | ||
120 | } } | ||
121 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
122 | protected override bool _HasAllPBJFields{ get { | ||
123 | return true | ||
124 | ; | ||
125 | } } | ||
126 | public bool IsInitialized { get { | ||
127 | return super.IsInitialized&&_HasAllPBJFields; | ||
128 | } } | ||
129 | protected _PBJ_Internal.StorageKey.Builder super; | ||
130 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
131 | public _PBJ_Internal.StorageKey.Builder _PBJSuper{ get { return super;} } | ||
132 | public Builder() {super = new _PBJ_Internal.StorageKey.Builder();} | ||
133 | public Builder(_PBJ_Internal.StorageKey.Builder other) { | ||
134 | super=other; | ||
135 | } | ||
136 | public Builder Clone() {return new Builder(super.Clone());} | ||
137 | public Builder MergeFrom(StorageKey prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
138 | public Builder Clear() {super.Clear();return this;} | ||
139 | public StorageKey BuildPartial() {return new StorageKey(super.BuildPartial());} | ||
140 | public StorageKey Build() {if (_HasAllPBJFields) return new StorageKey(super.Build());return null;} | ||
141 | public pbd::MessageDescriptor DescriptorForType { | ||
142 | get { return StorageKey.Descriptor; } } | ||
143 | public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} | ||
144 | public const int ObjectUuidFieldTag=9; | ||
145 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
146 | public PBJ.UUID ObjectUuid{ get { | ||
147 | if (HasObjectUuid) { | ||
148 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
149 | } else { | ||
150 | return PBJ._PBJ.CastUuid(); | ||
151 | } | ||
152 | } | ||
153 | set { | ||
154 | super.ObjectUuid=(PBJ._PBJ.Construct(value)); | ||
155 | } | ||
156 | } | ||
157 | public Builder ClearFieldId() { super.ClearFieldId();return this;} | ||
158 | public const int FieldIdFieldTag=10; | ||
159 | public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } | ||
160 | public ulong FieldId{ get { | ||
161 | if (HasFieldId) { | ||
162 | return PBJ._PBJ.CastUint64(super.FieldId); | ||
163 | } else { | ||
164 | return PBJ._PBJ.CastUint64(); | ||
165 | } | ||
166 | } | ||
167 | set { | ||
168 | super.FieldId=(PBJ._PBJ.Construct(value)); | ||
169 | } | ||
170 | } | ||
171 | public Builder ClearFieldName() { super.ClearFieldName();return this;} | ||
172 | public const int FieldNameFieldTag=11; | ||
173 | public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } | ||
174 | public string FieldName{ get { | ||
175 | if (HasFieldName) { | ||
176 | return PBJ._PBJ.CastString(super.FieldName); | ||
177 | } else { | ||
178 | return PBJ._PBJ.CastString(); | ||
179 | } | ||
180 | } | ||
181 | set { | ||
182 | super.FieldName=(PBJ._PBJ.Construct(value)); | ||
183 | } | ||
184 | } | ||
185 | } | ||
186 | } | ||
187 | } | ||
188 | namespace Sirikata.Persistence.Protocol { | ||
189 | public class StorageValue : PBJ.IMessage { | ||
190 | protected _PBJ_Internal.StorageValue super; | ||
191 | public _PBJ_Internal.StorageValue _PBJSuper{ get { return super;} } | ||
192 | public StorageValue() { | ||
193 | super=new _PBJ_Internal.StorageValue(); | ||
194 | } | ||
195 | public StorageValue(_PBJ_Internal.StorageValue reference) { | ||
196 | super=reference; | ||
197 | } | ||
198 | public static StorageValue defaultInstance= new StorageValue (_PBJ_Internal.StorageValue.DefaultInstance); | ||
199 | public static StorageValue DefaultInstance{ | ||
200 | get {return defaultInstance;} | ||
201 | } | ||
202 | public static pbd.MessageDescriptor Descriptor { | ||
203 | get { return _PBJ_Internal.StorageValue.Descriptor; } } | ||
204 | public static class Types { | ||
205 | } | ||
206 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
207 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
208 | } | ||
209 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
210 | return false; | ||
211 | } | ||
212 | public const int DataFieldTag=12; | ||
213 | public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } | ||
214 | public pb::ByteString Data{ get { | ||
215 | if (HasData) { | ||
216 | return PBJ._PBJ.CastBytes(super.Data); | ||
217 | } else { | ||
218 | return PBJ._PBJ.CastBytes(); | ||
219 | } | ||
220 | } | ||
221 | } | ||
222 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
223 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
224 | public static Builder CreateBuilder() { return new Builder(); } | ||
225 | public static Builder CreateBuilder(StorageValue prototype) { | ||
226 | return (Builder)new Builder().MergeFrom(prototype); | ||
227 | } | ||
228 | public static StorageValue ParseFrom(pb::ByteString data) { | ||
229 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); | ||
230 | } | ||
231 | public static StorageValue ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
232 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); | ||
233 | } | ||
234 | public static StorageValue ParseFrom(byte[] data) { | ||
235 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); | ||
236 | } | ||
237 | public static StorageValue ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
238 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); | ||
239 | } | ||
240 | public static StorageValue ParseFrom(global::System.IO.Stream data) { | ||
241 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); | ||
242 | } | ||
243 | public static StorageValue ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
244 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); | ||
245 | } | ||
246 | public static StorageValue ParseFrom(pb::CodedInputStream data) { | ||
247 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data)); | ||
248 | } | ||
249 | public static StorageValue ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
250 | return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er)); | ||
251 | } | ||
252 | protected override bool _HasAllPBJFields{ get { | ||
253 | return true | ||
254 | ; | ||
255 | } } | ||
256 | public bool IsInitialized { get { | ||
257 | return super.IsInitialized&&_HasAllPBJFields; | ||
258 | } } | ||
259 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
260 | protected override bool _HasAllPBJFields{ get { | ||
261 | return true | ||
262 | ; | ||
263 | } } | ||
264 | public bool IsInitialized { get { | ||
265 | return super.IsInitialized&&_HasAllPBJFields; | ||
266 | } } | ||
267 | protected _PBJ_Internal.StorageValue.Builder super; | ||
268 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
269 | public _PBJ_Internal.StorageValue.Builder _PBJSuper{ get { return super;} } | ||
270 | public Builder() {super = new _PBJ_Internal.StorageValue.Builder();} | ||
271 | public Builder(_PBJ_Internal.StorageValue.Builder other) { | ||
272 | super=other; | ||
273 | } | ||
274 | public Builder Clone() {return new Builder(super.Clone());} | ||
275 | public Builder MergeFrom(StorageValue prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
276 | public Builder Clear() {super.Clear();return this;} | ||
277 | public StorageValue BuildPartial() {return new StorageValue(super.BuildPartial());} | ||
278 | public StorageValue Build() {if (_HasAllPBJFields) return new StorageValue(super.Build());return null;} | ||
279 | public pbd::MessageDescriptor DescriptorForType { | ||
280 | get { return StorageValue.Descriptor; } } | ||
281 | public Builder ClearData() { super.ClearData();return this;} | ||
282 | public const int DataFieldTag=12; | ||
283 | public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } | ||
284 | public pb::ByteString Data{ get { | ||
285 | if (HasData) { | ||
286 | return PBJ._PBJ.CastBytes(super.Data); | ||
287 | } else { | ||
288 | return PBJ._PBJ.CastBytes(); | ||
289 | } | ||
290 | } | ||
291 | set { | ||
292 | super.Data=(PBJ._PBJ.Construct(value)); | ||
293 | } | ||
294 | } | ||
295 | } | ||
296 | } | ||
297 | } | ||
298 | namespace Sirikata.Persistence.Protocol { | ||
299 | public class StorageElement : PBJ.IMessage { | ||
300 | protected _PBJ_Internal.StorageElement super; | ||
301 | public _PBJ_Internal.StorageElement _PBJSuper{ get { return super;} } | ||
302 | public StorageElement() { | ||
303 | super=new _PBJ_Internal.StorageElement(); | ||
304 | } | ||
305 | public StorageElement(_PBJ_Internal.StorageElement reference) { | ||
306 | super=reference; | ||
307 | } | ||
308 | public static StorageElement defaultInstance= new StorageElement (_PBJ_Internal.StorageElement.DefaultInstance); | ||
309 | public static StorageElement DefaultInstance{ | ||
310 | get {return defaultInstance;} | ||
311 | } | ||
312 | public static pbd.MessageDescriptor Descriptor { | ||
313 | get { return _PBJ_Internal.StorageElement.Descriptor; } } | ||
314 | public static class Types { | ||
315 | public enum ReturnStatus { | ||
316 | KEY_MISSING=_PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING, | ||
317 | INTERNAL_ERROR=_PBJ_Internal.StorageElement.Types.ReturnStatus.INTERNAL_ERROR | ||
318 | }; | ||
319 | } | ||
320 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
321 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
322 | } | ||
323 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
324 | return false; | ||
325 | } | ||
326 | public const int ObjectUuidFieldTag=9; | ||
327 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
328 | public PBJ.UUID ObjectUuid{ get { | ||
329 | if (HasObjectUuid) { | ||
330 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
331 | } else { | ||
332 | return PBJ._PBJ.CastUuid(); | ||
333 | } | ||
334 | } | ||
335 | } | ||
336 | public const int FieldIdFieldTag=10; | ||
337 | public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } | ||
338 | public ulong FieldId{ get { | ||
339 | if (HasFieldId) { | ||
340 | return PBJ._PBJ.CastUint64(super.FieldId); | ||
341 | } else { | ||
342 | return PBJ._PBJ.CastUint64(); | ||
343 | } | ||
344 | } | ||
345 | } | ||
346 | public const int FieldNameFieldTag=11; | ||
347 | public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } | ||
348 | public string FieldName{ get { | ||
349 | if (HasFieldName) { | ||
350 | return PBJ._PBJ.CastString(super.FieldName); | ||
351 | } else { | ||
352 | return PBJ._PBJ.CastString(); | ||
353 | } | ||
354 | } | ||
355 | } | ||
356 | public const int DataFieldTag=12; | ||
357 | public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } | ||
358 | public pb::ByteString Data{ get { | ||
359 | if (HasData) { | ||
360 | return PBJ._PBJ.CastBytes(super.Data); | ||
361 | } else { | ||
362 | return PBJ._PBJ.CastBytes(); | ||
363 | } | ||
364 | } | ||
365 | } | ||
366 | public const int IndexFieldTag=13; | ||
367 | public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} } | ||
368 | public int Index{ get { | ||
369 | if (HasIndex) { | ||
370 | return PBJ._PBJ.CastInt32(super.Index); | ||
371 | } else { | ||
372 | return PBJ._PBJ.CastInt32(); | ||
373 | } | ||
374 | } | ||
375 | } | ||
376 | public const int ReturnStatusFieldTag=15; | ||
377 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
378 | public Types.ReturnStatus ReturnStatus{ get { | ||
379 | if (HasReturnStatus) { | ||
380 | return (Types.ReturnStatus)super.ReturnStatus; | ||
381 | } else { | ||
382 | return new Types.ReturnStatus(); | ||
383 | } | ||
384 | } | ||
385 | } | ||
386 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
387 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
388 | public static Builder CreateBuilder() { return new Builder(); } | ||
389 | public static Builder CreateBuilder(StorageElement prototype) { | ||
390 | return (Builder)new Builder().MergeFrom(prototype); | ||
391 | } | ||
392 | public static StorageElement ParseFrom(pb::ByteString data) { | ||
393 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); | ||
394 | } | ||
395 | public static StorageElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
396 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); | ||
397 | } | ||
398 | public static StorageElement ParseFrom(byte[] data) { | ||
399 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); | ||
400 | } | ||
401 | public static StorageElement ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
402 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); | ||
403 | } | ||
404 | public static StorageElement ParseFrom(global::System.IO.Stream data) { | ||
405 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); | ||
406 | } | ||
407 | public static StorageElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
408 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); | ||
409 | } | ||
410 | public static StorageElement ParseFrom(pb::CodedInputStream data) { | ||
411 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data)); | ||
412 | } | ||
413 | public static StorageElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
414 | return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er)); | ||
415 | } | ||
416 | protected override bool _HasAllPBJFields{ get { | ||
417 | return true | ||
418 | ; | ||
419 | } } | ||
420 | public bool IsInitialized { get { | ||
421 | return super.IsInitialized&&_HasAllPBJFields; | ||
422 | } } | ||
423 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
424 | protected override bool _HasAllPBJFields{ get { | ||
425 | return true | ||
426 | ; | ||
427 | } } | ||
428 | public bool IsInitialized { get { | ||
429 | return super.IsInitialized&&_HasAllPBJFields; | ||
430 | } } | ||
431 | protected _PBJ_Internal.StorageElement.Builder super; | ||
432 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
433 | public _PBJ_Internal.StorageElement.Builder _PBJSuper{ get { return super;} } | ||
434 | public Builder() {super = new _PBJ_Internal.StorageElement.Builder();} | ||
435 | public Builder(_PBJ_Internal.StorageElement.Builder other) { | ||
436 | super=other; | ||
437 | } | ||
438 | public Builder Clone() {return new Builder(super.Clone());} | ||
439 | public Builder MergeFrom(StorageElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
440 | public Builder Clear() {super.Clear();return this;} | ||
441 | public StorageElement BuildPartial() {return new StorageElement(super.BuildPartial());} | ||
442 | public StorageElement Build() {if (_HasAllPBJFields) return new StorageElement(super.Build());return null;} | ||
443 | public pbd::MessageDescriptor DescriptorForType { | ||
444 | get { return StorageElement.Descriptor; } } | ||
445 | public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} | ||
446 | public const int ObjectUuidFieldTag=9; | ||
447 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
448 | public PBJ.UUID ObjectUuid{ get { | ||
449 | if (HasObjectUuid) { | ||
450 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
451 | } else { | ||
452 | return PBJ._PBJ.CastUuid(); | ||
453 | } | ||
454 | } | ||
455 | set { | ||
456 | super.ObjectUuid=(PBJ._PBJ.Construct(value)); | ||
457 | } | ||
458 | } | ||
459 | public Builder ClearFieldId() { super.ClearFieldId();return this;} | ||
460 | public const int FieldIdFieldTag=10; | ||
461 | public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } | ||
462 | public ulong FieldId{ get { | ||
463 | if (HasFieldId) { | ||
464 | return PBJ._PBJ.CastUint64(super.FieldId); | ||
465 | } else { | ||
466 | return PBJ._PBJ.CastUint64(); | ||
467 | } | ||
468 | } | ||
469 | set { | ||
470 | super.FieldId=(PBJ._PBJ.Construct(value)); | ||
471 | } | ||
472 | } | ||
473 | public Builder ClearFieldName() { super.ClearFieldName();return this;} | ||
474 | public const int FieldNameFieldTag=11; | ||
475 | public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } | ||
476 | public string FieldName{ get { | ||
477 | if (HasFieldName) { | ||
478 | return PBJ._PBJ.CastString(super.FieldName); | ||
479 | } else { | ||
480 | return PBJ._PBJ.CastString(); | ||
481 | } | ||
482 | } | ||
483 | set { | ||
484 | super.FieldName=(PBJ._PBJ.Construct(value)); | ||
485 | } | ||
486 | } | ||
487 | public Builder ClearData() { super.ClearData();return this;} | ||
488 | public const int DataFieldTag=12; | ||
489 | public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } | ||
490 | public pb::ByteString Data{ get { | ||
491 | if (HasData) { | ||
492 | return PBJ._PBJ.CastBytes(super.Data); | ||
493 | } else { | ||
494 | return PBJ._PBJ.CastBytes(); | ||
495 | } | ||
496 | } | ||
497 | set { | ||
498 | super.Data=(PBJ._PBJ.Construct(value)); | ||
499 | } | ||
500 | } | ||
501 | public Builder ClearIndex() { super.ClearIndex();return this;} | ||
502 | public const int IndexFieldTag=13; | ||
503 | public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} } | ||
504 | public int Index{ get { | ||
505 | if (HasIndex) { | ||
506 | return PBJ._PBJ.CastInt32(super.Index); | ||
507 | } else { | ||
508 | return PBJ._PBJ.CastInt32(); | ||
509 | } | ||
510 | } | ||
511 | set { | ||
512 | super.Index=(PBJ._PBJ.Construct(value)); | ||
513 | } | ||
514 | } | ||
515 | public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} | ||
516 | public const int ReturnStatusFieldTag=15; | ||
517 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
518 | public Types.ReturnStatus ReturnStatus{ get { | ||
519 | if (HasReturnStatus) { | ||
520 | return (Types.ReturnStatus)super.ReturnStatus; | ||
521 | } else { | ||
522 | return new Types.ReturnStatus(); | ||
523 | } | ||
524 | } | ||
525 | set { | ||
526 | super.ReturnStatus=((_PBJ_Internal.StorageElement.Types.ReturnStatus)value); | ||
527 | } | ||
528 | } | ||
529 | } | ||
530 | } | ||
531 | } | ||
532 | namespace Sirikata.Persistence.Protocol { | ||
533 | public class CompareElement : PBJ.IMessage { | ||
534 | protected _PBJ_Internal.CompareElement super; | ||
535 | public _PBJ_Internal.CompareElement _PBJSuper{ get { return super;} } | ||
536 | public CompareElement() { | ||
537 | super=new _PBJ_Internal.CompareElement(); | ||
538 | } | ||
539 | public CompareElement(_PBJ_Internal.CompareElement reference) { | ||
540 | super=reference; | ||
541 | } | ||
542 | public static CompareElement defaultInstance= new CompareElement (_PBJ_Internal.CompareElement.DefaultInstance); | ||
543 | public static CompareElement DefaultInstance{ | ||
544 | get {return defaultInstance;} | ||
545 | } | ||
546 | public static pbd.MessageDescriptor Descriptor { | ||
547 | get { return _PBJ_Internal.CompareElement.Descriptor; } } | ||
548 | public static class Types { | ||
549 | public enum COMPARATOR { | ||
550 | EQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL, | ||
551 | NEQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.NEQUAL | ||
552 | }; | ||
553 | } | ||
554 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
555 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
556 | } | ||
557 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
558 | return false; | ||
559 | } | ||
560 | public const int ObjectUuidFieldTag=9; | ||
561 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
562 | public PBJ.UUID ObjectUuid{ get { | ||
563 | if (HasObjectUuid) { | ||
564 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
565 | } else { | ||
566 | return PBJ._PBJ.CastUuid(); | ||
567 | } | ||
568 | } | ||
569 | } | ||
570 | public const int FieldIdFieldTag=10; | ||
571 | public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } | ||
572 | public ulong FieldId{ get { | ||
573 | if (HasFieldId) { | ||
574 | return PBJ._PBJ.CastUint64(super.FieldId); | ||
575 | } else { | ||
576 | return PBJ._PBJ.CastUint64(); | ||
577 | } | ||
578 | } | ||
579 | } | ||
580 | public const int FieldNameFieldTag=11; | ||
581 | public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } | ||
582 | public string FieldName{ get { | ||
583 | if (HasFieldName) { | ||
584 | return PBJ._PBJ.CastString(super.FieldName); | ||
585 | } else { | ||
586 | return PBJ._PBJ.CastString(); | ||
587 | } | ||
588 | } | ||
589 | } | ||
590 | public const int DataFieldTag=12; | ||
591 | public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } | ||
592 | public pb::ByteString Data{ get { | ||
593 | if (HasData) { | ||
594 | return PBJ._PBJ.CastBytes(super.Data); | ||
595 | } else { | ||
596 | return PBJ._PBJ.CastBytes(); | ||
597 | } | ||
598 | } | ||
599 | } | ||
600 | public const int ComparatorFieldTag=14; | ||
601 | public bool HasComparator{ get {return super.HasComparator;} } | ||
602 | public Types.COMPARATOR Comparator{ get { | ||
603 | if (HasComparator) { | ||
604 | return (Types.COMPARATOR)super.Comparator; | ||
605 | } else { | ||
606 | return new Types.COMPARATOR(); | ||
607 | } | ||
608 | } | ||
609 | } | ||
610 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
611 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
612 | public static Builder CreateBuilder() { return new Builder(); } | ||
613 | public static Builder CreateBuilder(CompareElement prototype) { | ||
614 | return (Builder)new Builder().MergeFrom(prototype); | ||
615 | } | ||
616 | public static CompareElement ParseFrom(pb::ByteString data) { | ||
617 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); | ||
618 | } | ||
619 | public static CompareElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
620 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); | ||
621 | } | ||
622 | public static CompareElement ParseFrom(byte[] data) { | ||
623 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); | ||
624 | } | ||
625 | public static CompareElement ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
626 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); | ||
627 | } | ||
628 | public static CompareElement ParseFrom(global::System.IO.Stream data) { | ||
629 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); | ||
630 | } | ||
631 | public static CompareElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
632 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); | ||
633 | } | ||
634 | public static CompareElement ParseFrom(pb::CodedInputStream data) { | ||
635 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data)); | ||
636 | } | ||
637 | public static CompareElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
638 | return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er)); | ||
639 | } | ||
640 | protected override bool _HasAllPBJFields{ get { | ||
641 | return true | ||
642 | ; | ||
643 | } } | ||
644 | public bool IsInitialized { get { | ||
645 | return super.IsInitialized&&_HasAllPBJFields; | ||
646 | } } | ||
647 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
648 | protected override bool _HasAllPBJFields{ get { | ||
649 | return true | ||
650 | ; | ||
651 | } } | ||
652 | public bool IsInitialized { get { | ||
653 | return super.IsInitialized&&_HasAllPBJFields; | ||
654 | } } | ||
655 | protected _PBJ_Internal.CompareElement.Builder super; | ||
656 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
657 | public _PBJ_Internal.CompareElement.Builder _PBJSuper{ get { return super;} } | ||
658 | public Builder() {super = new _PBJ_Internal.CompareElement.Builder();} | ||
659 | public Builder(_PBJ_Internal.CompareElement.Builder other) { | ||
660 | super=other; | ||
661 | } | ||
662 | public Builder Clone() {return new Builder(super.Clone());} | ||
663 | public Builder MergeFrom(CompareElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
664 | public Builder Clear() {super.Clear();return this;} | ||
665 | public CompareElement BuildPartial() {return new CompareElement(super.BuildPartial());} | ||
666 | public CompareElement Build() {if (_HasAllPBJFields) return new CompareElement(super.Build());return null;} | ||
667 | public pbd::MessageDescriptor DescriptorForType { | ||
668 | get { return CompareElement.Descriptor; } } | ||
669 | public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} | ||
670 | public const int ObjectUuidFieldTag=9; | ||
671 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
672 | public PBJ.UUID ObjectUuid{ get { | ||
673 | if (HasObjectUuid) { | ||
674 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
675 | } else { | ||
676 | return PBJ._PBJ.CastUuid(); | ||
677 | } | ||
678 | } | ||
679 | set { | ||
680 | super.ObjectUuid=(PBJ._PBJ.Construct(value)); | ||
681 | } | ||
682 | } | ||
683 | public Builder ClearFieldId() { super.ClearFieldId();return this;} | ||
684 | public const int FieldIdFieldTag=10; | ||
685 | public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} } | ||
686 | public ulong FieldId{ get { | ||
687 | if (HasFieldId) { | ||
688 | return PBJ._PBJ.CastUint64(super.FieldId); | ||
689 | } else { | ||
690 | return PBJ._PBJ.CastUint64(); | ||
691 | } | ||
692 | } | ||
693 | set { | ||
694 | super.FieldId=(PBJ._PBJ.Construct(value)); | ||
695 | } | ||
696 | } | ||
697 | public Builder ClearFieldName() { super.ClearFieldName();return this;} | ||
698 | public const int FieldNameFieldTag=11; | ||
699 | public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} } | ||
700 | public string FieldName{ get { | ||
701 | if (HasFieldName) { | ||
702 | return PBJ._PBJ.CastString(super.FieldName); | ||
703 | } else { | ||
704 | return PBJ._PBJ.CastString(); | ||
705 | } | ||
706 | } | ||
707 | set { | ||
708 | super.FieldName=(PBJ._PBJ.Construct(value)); | ||
709 | } | ||
710 | } | ||
711 | public Builder ClearData() { super.ClearData();return this;} | ||
712 | public const int DataFieldTag=12; | ||
713 | public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} } | ||
714 | public pb::ByteString Data{ get { | ||
715 | if (HasData) { | ||
716 | return PBJ._PBJ.CastBytes(super.Data); | ||
717 | } else { | ||
718 | return PBJ._PBJ.CastBytes(); | ||
719 | } | ||
720 | } | ||
721 | set { | ||
722 | super.Data=(PBJ._PBJ.Construct(value)); | ||
723 | } | ||
724 | } | ||
725 | public Builder ClearComparator() { super.ClearComparator();return this;} | ||
726 | public const int ComparatorFieldTag=14; | ||
727 | public bool HasComparator{ get {return super.HasComparator;} } | ||
728 | public Types.COMPARATOR Comparator{ get { | ||
729 | if (HasComparator) { | ||
730 | return (Types.COMPARATOR)super.Comparator; | ||
731 | } else { | ||
732 | return new Types.COMPARATOR(); | ||
733 | } | ||
734 | } | ||
735 | set { | ||
736 | super.Comparator=((_PBJ_Internal.CompareElement.Types.COMPARATOR)value); | ||
737 | } | ||
738 | } | ||
739 | } | ||
740 | } | ||
741 | } | ||
742 | namespace Sirikata.Persistence.Protocol { | ||
743 | public class StorageSet : PBJ.IMessage { | ||
744 | protected _PBJ_Internal.StorageSet super; | ||
745 | public _PBJ_Internal.StorageSet _PBJSuper{ get { return super;} } | ||
746 | public StorageSet() { | ||
747 | super=new _PBJ_Internal.StorageSet(); | ||
748 | } | ||
749 | public StorageSet(_PBJ_Internal.StorageSet reference) { | ||
750 | super=reference; | ||
751 | } | ||
752 | public static StorageSet defaultInstance= new StorageSet (_PBJ_Internal.StorageSet.DefaultInstance); | ||
753 | public static StorageSet DefaultInstance{ | ||
754 | get {return defaultInstance;} | ||
755 | } | ||
756 | public static pbd.MessageDescriptor Descriptor { | ||
757 | get { return _PBJ_Internal.StorageSet.Descriptor; } } | ||
758 | public static class Types { | ||
759 | } | ||
760 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
761 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
762 | } | ||
763 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
764 | return false; | ||
765 | } | ||
766 | public const int ReadsFieldTag=9; | ||
767 | public int ReadsCount { get { return super.ReadsCount;} } | ||
768 | public bool HasReads(int index) {return true;} | ||
769 | public StorageElement Reads(int index) { | ||
770 | return new StorageElement(super.GetReads(index)); | ||
771 | } | ||
772 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
773 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
774 | public static Builder CreateBuilder() { return new Builder(); } | ||
775 | public static Builder CreateBuilder(StorageSet prototype) { | ||
776 | return (Builder)new Builder().MergeFrom(prototype); | ||
777 | } | ||
778 | public static StorageSet ParseFrom(pb::ByteString data) { | ||
779 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); | ||
780 | } | ||
781 | public static StorageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
782 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); | ||
783 | } | ||
784 | public static StorageSet ParseFrom(byte[] data) { | ||
785 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); | ||
786 | } | ||
787 | public static StorageSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
788 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); | ||
789 | } | ||
790 | public static StorageSet ParseFrom(global::System.IO.Stream data) { | ||
791 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); | ||
792 | } | ||
793 | public static StorageSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
794 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); | ||
795 | } | ||
796 | public static StorageSet ParseFrom(pb::CodedInputStream data) { | ||
797 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data)); | ||
798 | } | ||
799 | public static StorageSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
800 | return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er)); | ||
801 | } | ||
802 | protected override bool _HasAllPBJFields{ get { | ||
803 | return true | ||
804 | ; | ||
805 | } } | ||
806 | public bool IsInitialized { get { | ||
807 | return super.IsInitialized&&_HasAllPBJFields; | ||
808 | } } | ||
809 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
810 | protected override bool _HasAllPBJFields{ get { | ||
811 | return true | ||
812 | ; | ||
813 | } } | ||
814 | public bool IsInitialized { get { | ||
815 | return super.IsInitialized&&_HasAllPBJFields; | ||
816 | } } | ||
817 | protected _PBJ_Internal.StorageSet.Builder super; | ||
818 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
819 | public _PBJ_Internal.StorageSet.Builder _PBJSuper{ get { return super;} } | ||
820 | public Builder() {super = new _PBJ_Internal.StorageSet.Builder();} | ||
821 | public Builder(_PBJ_Internal.StorageSet.Builder other) { | ||
822 | super=other; | ||
823 | } | ||
824 | public Builder Clone() {return new Builder(super.Clone());} | ||
825 | public Builder MergeFrom(StorageSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
826 | public Builder Clear() {super.Clear();return this;} | ||
827 | public StorageSet BuildPartial() {return new StorageSet(super.BuildPartial());} | ||
828 | public StorageSet Build() {if (_HasAllPBJFields) return new StorageSet(super.Build());return null;} | ||
829 | public pbd::MessageDescriptor DescriptorForType { | ||
830 | get { return StorageSet.Descriptor; } } | ||
831 | public Builder ClearReads() { super.ClearReads();return this;} | ||
832 | public Builder SetReads(int index,StorageElement value) { | ||
833 | super.SetReads(index,value._PBJSuper); | ||
834 | return this; | ||
835 | } | ||
836 | public const int ReadsFieldTag=9; | ||
837 | public int ReadsCount { get { return super.ReadsCount;} } | ||
838 | public bool HasReads(int index) {return true;} | ||
839 | public StorageElement Reads(int index) { | ||
840 | return new StorageElement(super.GetReads(index)); | ||
841 | } | ||
842 | public Builder AddReads(StorageElement value) { | ||
843 | super.AddReads(value._PBJSuper); | ||
844 | return this; | ||
845 | } | ||
846 | } | ||
847 | } | ||
848 | } | ||
849 | namespace Sirikata.Persistence.Protocol { | ||
850 | public class ReadSet : PBJ.IMessage { | ||
851 | protected _PBJ_Internal.ReadSet super; | ||
852 | public _PBJ_Internal.ReadSet _PBJSuper{ get { return super;} } | ||
853 | public ReadSet() { | ||
854 | super=new _PBJ_Internal.ReadSet(); | ||
855 | } | ||
856 | public ReadSet(_PBJ_Internal.ReadSet reference) { | ||
857 | super=reference; | ||
858 | } | ||
859 | public static ReadSet defaultInstance= new ReadSet (_PBJ_Internal.ReadSet.DefaultInstance); | ||
860 | public static ReadSet DefaultInstance{ | ||
861 | get {return defaultInstance;} | ||
862 | } | ||
863 | public static pbd.MessageDescriptor Descriptor { | ||
864 | get { return _PBJ_Internal.ReadSet.Descriptor; } } | ||
865 | public static class Types { | ||
866 | } | ||
867 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
868 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
869 | } | ||
870 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
871 | return false; | ||
872 | } | ||
873 | public const int ReadsFieldTag=9; | ||
874 | public int ReadsCount { get { return super.ReadsCount;} } | ||
875 | public bool HasReads(int index) {return true;} | ||
876 | public StorageElement Reads(int index) { | ||
877 | return new StorageElement(super.GetReads(index)); | ||
878 | } | ||
879 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
880 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
881 | public static Builder CreateBuilder() { return new Builder(); } | ||
882 | public static Builder CreateBuilder(ReadSet prototype) { | ||
883 | return (Builder)new Builder().MergeFrom(prototype); | ||
884 | } | ||
885 | public static ReadSet ParseFrom(pb::ByteString data) { | ||
886 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); | ||
887 | } | ||
888 | public static ReadSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
889 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); | ||
890 | } | ||
891 | public static ReadSet ParseFrom(byte[] data) { | ||
892 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); | ||
893 | } | ||
894 | public static ReadSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
895 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); | ||
896 | } | ||
897 | public static ReadSet ParseFrom(global::System.IO.Stream data) { | ||
898 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); | ||
899 | } | ||
900 | public static ReadSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
901 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); | ||
902 | } | ||
903 | public static ReadSet ParseFrom(pb::CodedInputStream data) { | ||
904 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data)); | ||
905 | } | ||
906 | public static ReadSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
907 | return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er)); | ||
908 | } | ||
909 | protected override bool _HasAllPBJFields{ get { | ||
910 | return true | ||
911 | ; | ||
912 | } } | ||
913 | public bool IsInitialized { get { | ||
914 | return super.IsInitialized&&_HasAllPBJFields; | ||
915 | } } | ||
916 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
917 | protected override bool _HasAllPBJFields{ get { | ||
918 | return true | ||
919 | ; | ||
920 | } } | ||
921 | public bool IsInitialized { get { | ||
922 | return super.IsInitialized&&_HasAllPBJFields; | ||
923 | } } | ||
924 | protected _PBJ_Internal.ReadSet.Builder super; | ||
925 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
926 | public _PBJ_Internal.ReadSet.Builder _PBJSuper{ get { return super;} } | ||
927 | public Builder() {super = new _PBJ_Internal.ReadSet.Builder();} | ||
928 | public Builder(_PBJ_Internal.ReadSet.Builder other) { | ||
929 | super=other; | ||
930 | } | ||
931 | public Builder Clone() {return new Builder(super.Clone());} | ||
932 | public Builder MergeFrom(ReadSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
933 | public Builder Clear() {super.Clear();return this;} | ||
934 | public ReadSet BuildPartial() {return new ReadSet(super.BuildPartial());} | ||
935 | public ReadSet Build() {if (_HasAllPBJFields) return new ReadSet(super.Build());return null;} | ||
936 | public pbd::MessageDescriptor DescriptorForType { | ||
937 | get { return ReadSet.Descriptor; } } | ||
938 | public Builder ClearReads() { super.ClearReads();return this;} | ||
939 | public Builder SetReads(int index,StorageElement value) { | ||
940 | super.SetReads(index,value._PBJSuper); | ||
941 | return this; | ||
942 | } | ||
943 | public const int ReadsFieldTag=9; | ||
944 | public int ReadsCount { get { return super.ReadsCount;} } | ||
945 | public bool HasReads(int index) {return true;} | ||
946 | public StorageElement Reads(int index) { | ||
947 | return new StorageElement(super.GetReads(index)); | ||
948 | } | ||
949 | public Builder AddReads(StorageElement value) { | ||
950 | super.AddReads(value._PBJSuper); | ||
951 | return this; | ||
952 | } | ||
953 | } | ||
954 | } | ||
955 | } | ||
956 | namespace Sirikata.Persistence.Protocol { | ||
957 | public class WriteSet : PBJ.IMessage { | ||
958 | protected _PBJ_Internal.WriteSet super; | ||
959 | public _PBJ_Internal.WriteSet _PBJSuper{ get { return super;} } | ||
960 | public WriteSet() { | ||
961 | super=new _PBJ_Internal.WriteSet(); | ||
962 | } | ||
963 | public WriteSet(_PBJ_Internal.WriteSet reference) { | ||
964 | super=reference; | ||
965 | } | ||
966 | public static WriteSet defaultInstance= new WriteSet (_PBJ_Internal.WriteSet.DefaultInstance); | ||
967 | public static WriteSet DefaultInstance{ | ||
968 | get {return defaultInstance;} | ||
969 | } | ||
970 | public static pbd.MessageDescriptor Descriptor { | ||
971 | get { return _PBJ_Internal.WriteSet.Descriptor; } } | ||
972 | public static class Types { | ||
973 | } | ||
974 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
975 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
976 | } | ||
977 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
978 | return false; | ||
979 | } | ||
980 | public const int WritesFieldTag=10; | ||
981 | public int WritesCount { get { return super.WritesCount;} } | ||
982 | public bool HasWrites(int index) {return true;} | ||
983 | public StorageElement Writes(int index) { | ||
984 | return new StorageElement(super.GetWrites(index)); | ||
985 | } | ||
986 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
987 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
988 | public static Builder CreateBuilder() { return new Builder(); } | ||
989 | public static Builder CreateBuilder(WriteSet prototype) { | ||
990 | return (Builder)new Builder().MergeFrom(prototype); | ||
991 | } | ||
992 | public static WriteSet ParseFrom(pb::ByteString data) { | ||
993 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); | ||
994 | } | ||
995 | public static WriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
996 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); | ||
997 | } | ||
998 | public static WriteSet ParseFrom(byte[] data) { | ||
999 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); | ||
1000 | } | ||
1001 | public static WriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1002 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); | ||
1003 | } | ||
1004 | public static WriteSet ParseFrom(global::System.IO.Stream data) { | ||
1005 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); | ||
1006 | } | ||
1007 | public static WriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1008 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); | ||
1009 | } | ||
1010 | public static WriteSet ParseFrom(pb::CodedInputStream data) { | ||
1011 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data)); | ||
1012 | } | ||
1013 | public static WriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1014 | return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er)); | ||
1015 | } | ||
1016 | protected override bool _HasAllPBJFields{ get { | ||
1017 | return true | ||
1018 | ; | ||
1019 | } } | ||
1020 | public bool IsInitialized { get { | ||
1021 | return super.IsInitialized&&_HasAllPBJFields; | ||
1022 | } } | ||
1023 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1024 | protected override bool _HasAllPBJFields{ get { | ||
1025 | return true | ||
1026 | ; | ||
1027 | } } | ||
1028 | public bool IsInitialized { get { | ||
1029 | return super.IsInitialized&&_HasAllPBJFields; | ||
1030 | } } | ||
1031 | protected _PBJ_Internal.WriteSet.Builder super; | ||
1032 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1033 | public _PBJ_Internal.WriteSet.Builder _PBJSuper{ get { return super;} } | ||
1034 | public Builder() {super = new _PBJ_Internal.WriteSet.Builder();} | ||
1035 | public Builder(_PBJ_Internal.WriteSet.Builder other) { | ||
1036 | super=other; | ||
1037 | } | ||
1038 | public Builder Clone() {return new Builder(super.Clone());} | ||
1039 | public Builder MergeFrom(WriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1040 | public Builder Clear() {super.Clear();return this;} | ||
1041 | public WriteSet BuildPartial() {return new WriteSet(super.BuildPartial());} | ||
1042 | public WriteSet Build() {if (_HasAllPBJFields) return new WriteSet(super.Build());return null;} | ||
1043 | public pbd::MessageDescriptor DescriptorForType { | ||
1044 | get { return WriteSet.Descriptor; } } | ||
1045 | public Builder ClearWrites() { super.ClearWrites();return this;} | ||
1046 | public Builder SetWrites(int index,StorageElement value) { | ||
1047 | super.SetWrites(index,value._PBJSuper); | ||
1048 | return this; | ||
1049 | } | ||
1050 | public const int WritesFieldTag=10; | ||
1051 | public int WritesCount { get { return super.WritesCount;} } | ||
1052 | public bool HasWrites(int index) {return true;} | ||
1053 | public StorageElement Writes(int index) { | ||
1054 | return new StorageElement(super.GetWrites(index)); | ||
1055 | } | ||
1056 | public Builder AddWrites(StorageElement value) { | ||
1057 | super.AddWrites(value._PBJSuper); | ||
1058 | return this; | ||
1059 | } | ||
1060 | } | ||
1061 | } | ||
1062 | } | ||
1063 | namespace Sirikata.Persistence.Protocol { | ||
1064 | public class ReadWriteSet : PBJ.IMessage { | ||
1065 | protected _PBJ_Internal.ReadWriteSet super; | ||
1066 | public _PBJ_Internal.ReadWriteSet _PBJSuper{ get { return super;} } | ||
1067 | public ReadWriteSet() { | ||
1068 | super=new _PBJ_Internal.ReadWriteSet(); | ||
1069 | } | ||
1070 | public ReadWriteSet(_PBJ_Internal.ReadWriteSet reference) { | ||
1071 | super=reference; | ||
1072 | } | ||
1073 | public static ReadWriteSet defaultInstance= new ReadWriteSet (_PBJ_Internal.ReadWriteSet.DefaultInstance); | ||
1074 | public static ReadWriteSet DefaultInstance{ | ||
1075 | get {return defaultInstance;} | ||
1076 | } | ||
1077 | public static pbd.MessageDescriptor Descriptor { | ||
1078 | get { return _PBJ_Internal.ReadWriteSet.Descriptor; } } | ||
1079 | public static class Types { | ||
1080 | public enum ReadWriteSetOptions { | ||
1081 | RETURN_READ_NAMES=_PBJ_Internal.ReadWriteSet.Types.ReadWriteSetOptions.RETURN_READ_NAMES | ||
1082 | }; | ||
1083 | } | ||
1084 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1085 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
1086 | } | ||
1087 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1088 | return false; | ||
1089 | } | ||
1090 | public const int ReadsFieldTag=9; | ||
1091 | public int ReadsCount { get { return super.ReadsCount;} } | ||
1092 | public bool HasReads(int index) {return true;} | ||
1093 | public StorageElement Reads(int index) { | ||
1094 | return new StorageElement(super.GetReads(index)); | ||
1095 | } | ||
1096 | public const int WritesFieldTag=10; | ||
1097 | public int WritesCount { get { return super.WritesCount;} } | ||
1098 | public bool HasWrites(int index) {return true;} | ||
1099 | public StorageElement Writes(int index) { | ||
1100 | return new StorageElement(super.GetWrites(index)); | ||
1101 | } | ||
1102 | public const int OptionsFieldTag=14; | ||
1103 | public bool HasOptions { get { | ||
1104 | if (!super.HasOptions) return false; | ||
1105 | return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); | ||
1106 | } } | ||
1107 | public ulong Options{ get { | ||
1108 | if (HasOptions) { | ||
1109 | return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); | ||
1110 | } else { | ||
1111 | return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); | ||
1112 | } | ||
1113 | } | ||
1114 | } | ||
1115 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1116 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1117 | public static Builder CreateBuilder() { return new Builder(); } | ||
1118 | public static Builder CreateBuilder(ReadWriteSet prototype) { | ||
1119 | return (Builder)new Builder().MergeFrom(prototype); | ||
1120 | } | ||
1121 | public static ReadWriteSet ParseFrom(pb::ByteString data) { | ||
1122 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); | ||
1123 | } | ||
1124 | public static ReadWriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1125 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); | ||
1126 | } | ||
1127 | public static ReadWriteSet ParseFrom(byte[] data) { | ||
1128 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); | ||
1129 | } | ||
1130 | public static ReadWriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1131 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); | ||
1132 | } | ||
1133 | public static ReadWriteSet ParseFrom(global::System.IO.Stream data) { | ||
1134 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); | ||
1135 | } | ||
1136 | public static ReadWriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1137 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); | ||
1138 | } | ||
1139 | public static ReadWriteSet ParseFrom(pb::CodedInputStream data) { | ||
1140 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data)); | ||
1141 | } | ||
1142 | public static ReadWriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1143 | return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er)); | ||
1144 | } | ||
1145 | protected override bool _HasAllPBJFields{ get { | ||
1146 | return true | ||
1147 | ; | ||
1148 | } } | ||
1149 | public bool IsInitialized { get { | ||
1150 | return super.IsInitialized&&_HasAllPBJFields; | ||
1151 | } } | ||
1152 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1153 | protected override bool _HasAllPBJFields{ get { | ||
1154 | return true | ||
1155 | ; | ||
1156 | } } | ||
1157 | public bool IsInitialized { get { | ||
1158 | return super.IsInitialized&&_HasAllPBJFields; | ||
1159 | } } | ||
1160 | protected _PBJ_Internal.ReadWriteSet.Builder super; | ||
1161 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1162 | public _PBJ_Internal.ReadWriteSet.Builder _PBJSuper{ get { return super;} } | ||
1163 | public Builder() {super = new _PBJ_Internal.ReadWriteSet.Builder();} | ||
1164 | public Builder(_PBJ_Internal.ReadWriteSet.Builder other) { | ||
1165 | super=other; | ||
1166 | } | ||
1167 | public Builder Clone() {return new Builder(super.Clone());} | ||
1168 | public Builder MergeFrom(ReadWriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1169 | public Builder Clear() {super.Clear();return this;} | ||
1170 | public ReadWriteSet BuildPartial() {return new ReadWriteSet(super.BuildPartial());} | ||
1171 | public ReadWriteSet Build() {if (_HasAllPBJFields) return new ReadWriteSet(super.Build());return null;} | ||
1172 | public pbd::MessageDescriptor DescriptorForType { | ||
1173 | get { return ReadWriteSet.Descriptor; } } | ||
1174 | public Builder ClearReads() { super.ClearReads();return this;} | ||
1175 | public Builder SetReads(int index,StorageElement value) { | ||
1176 | super.SetReads(index,value._PBJSuper); | ||
1177 | return this; | ||
1178 | } | ||
1179 | public const int ReadsFieldTag=9; | ||
1180 | public int ReadsCount { get { return super.ReadsCount;} } | ||
1181 | public bool HasReads(int index) {return true;} | ||
1182 | public StorageElement Reads(int index) { | ||
1183 | return new StorageElement(super.GetReads(index)); | ||
1184 | } | ||
1185 | public Builder AddReads(StorageElement value) { | ||
1186 | super.AddReads(value._PBJSuper); | ||
1187 | return this; | ||
1188 | } | ||
1189 | public Builder ClearWrites() { super.ClearWrites();return this;} | ||
1190 | public Builder SetWrites(int index,StorageElement value) { | ||
1191 | super.SetWrites(index,value._PBJSuper); | ||
1192 | return this; | ||
1193 | } | ||
1194 | public const int WritesFieldTag=10; | ||
1195 | public int WritesCount { get { return super.WritesCount;} } | ||
1196 | public bool HasWrites(int index) {return true;} | ||
1197 | public StorageElement Writes(int index) { | ||
1198 | return new StorageElement(super.GetWrites(index)); | ||
1199 | } | ||
1200 | public Builder AddWrites(StorageElement value) { | ||
1201 | super.AddWrites(value._PBJSuper); | ||
1202 | return this; | ||
1203 | } | ||
1204 | public Builder ClearOptions() { super.ClearOptions();return this;} | ||
1205 | public const int OptionsFieldTag=14; | ||
1206 | public bool HasOptions { get { | ||
1207 | if (!super.HasOptions) return false; | ||
1208 | return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); | ||
1209 | } } | ||
1210 | public ulong Options{ get { | ||
1211 | if (HasOptions) { | ||
1212 | return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); | ||
1213 | } else { | ||
1214 | return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES); | ||
1215 | } | ||
1216 | } | ||
1217 | set { | ||
1218 | super.Options=((value)); | ||
1219 | } | ||
1220 | } | ||
1221 | } | ||
1222 | } | ||
1223 | } | ||
1224 | namespace Sirikata.Persistence.Protocol { | ||
1225 | public class Minitransaction : PBJ.IMessage { | ||
1226 | protected _PBJ_Internal.Minitransaction super; | ||
1227 | public _PBJ_Internal.Minitransaction _PBJSuper{ get { return super;} } | ||
1228 | public Minitransaction() { | ||
1229 | super=new _PBJ_Internal.Minitransaction(); | ||
1230 | } | ||
1231 | public Minitransaction(_PBJ_Internal.Minitransaction reference) { | ||
1232 | super=reference; | ||
1233 | } | ||
1234 | public static Minitransaction defaultInstance= new Minitransaction (_PBJ_Internal.Minitransaction.DefaultInstance); | ||
1235 | public static Minitransaction DefaultInstance{ | ||
1236 | get {return defaultInstance;} | ||
1237 | } | ||
1238 | public static pbd.MessageDescriptor Descriptor { | ||
1239 | get { return _PBJ_Internal.Minitransaction.Descriptor; } } | ||
1240 | public static class Types { | ||
1241 | public enum TransactionOptions { | ||
1242 | RETURN_READ_NAMES=_PBJ_Internal.Minitransaction.Types.TransactionOptions.RETURN_READ_NAMES | ||
1243 | }; | ||
1244 | } | ||
1245 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1246 | return false; | ||
1247 | } | ||
1248 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1249 | return false; | ||
1250 | } | ||
1251 | public const int ReadsFieldTag=9; | ||
1252 | public int ReadsCount { get { return super.ReadsCount;} } | ||
1253 | public bool HasReads(int index) {return true;} | ||
1254 | public StorageElement Reads(int index) { | ||
1255 | return new StorageElement(super.GetReads(index)); | ||
1256 | } | ||
1257 | public const int WritesFieldTag=10; | ||
1258 | public int WritesCount { get { return super.WritesCount;} } | ||
1259 | public bool HasWrites(int index) {return true;} | ||
1260 | public StorageElement Writes(int index) { | ||
1261 | return new StorageElement(super.GetWrites(index)); | ||
1262 | } | ||
1263 | public const int ComparesFieldTag=11; | ||
1264 | public int ComparesCount { get { return super.ComparesCount;} } | ||
1265 | public bool HasCompares(int index) {return true;} | ||
1266 | public CompareElement Compares(int index) { | ||
1267 | return new CompareElement(super.GetCompares(index)); | ||
1268 | } | ||
1269 | public const int OptionsFieldTag=14; | ||
1270 | public bool HasOptions { get { | ||
1271 | if (!super.HasOptions) return false; | ||
1272 | return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); | ||
1273 | } } | ||
1274 | public ulong Options{ get { | ||
1275 | if (HasOptions) { | ||
1276 | return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); | ||
1277 | } else { | ||
1278 | return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES); | ||
1279 | } | ||
1280 | } | ||
1281 | } | ||
1282 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1283 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1284 | public static Builder CreateBuilder() { return new Builder(); } | ||
1285 | public static Builder CreateBuilder(Minitransaction prototype) { | ||
1286 | return (Builder)new Builder().MergeFrom(prototype); | ||
1287 | } | ||
1288 | public static Minitransaction ParseFrom(pb::ByteString data) { | ||
1289 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); | ||
1290 | } | ||
1291 | public static Minitransaction ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1292 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); | ||
1293 | } | ||
1294 | public static Minitransaction ParseFrom(byte[] data) { | ||
1295 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); | ||
1296 | } | ||
1297 | public static Minitransaction ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1298 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); | ||
1299 | } | ||
1300 | public static Minitransaction ParseFrom(global::System.IO.Stream data) { | ||
1301 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); | ||
1302 | } | ||
1303 | public static Minitransaction ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1304 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); | ||
1305 | } | ||
1306 | public static Minitransaction ParseFrom(pb::CodedInputStream data) { | ||
1307 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data)); | ||
1308 | } | ||
1309 | public static Minitransaction ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1310 | return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er)); | ||
1311 | } | ||
1312 | protected override bool _HasAllPBJFields{ get { | ||
1313 | return true | ||
1314 | ; | ||
1315 | } } | ||
1316 | public bool IsInitialized { get { | ||
1317 | return super.IsInitialized&&_HasAllPBJFields; | ||
1318 | } } | ||
1319 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1320 | protected override bool _HasAllPBJFields{ get { | ||
1321 | return true | ||
1322 | ; | ||
1323 | } } | ||
1324 | public bool IsInitialized { get { | ||
1325 | return super.IsInitialized&&_HasAllPBJFields; | ||
1326 | } } | ||
1327 | protected _PBJ_Internal.Minitransaction.Builder super; | ||
1328 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1329 | public _PBJ_Internal.Minitransaction.Builder _PBJSuper{ get { return super;} } | ||
1330 | public Builder() {super = new _PBJ_Internal.Minitransaction.Builder();} | ||
1331 | public Builder(_PBJ_Internal.Minitransaction.Builder other) { | ||
1332 | super=other; | ||
1333 | } | ||
1334 | public Builder Clone() {return new Builder(super.Clone());} | ||
1335 | public Builder MergeFrom(Minitransaction prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1336 | public Builder Clear() {super.Clear();return this;} | ||
1337 | public Minitransaction BuildPartial() {return new Minitransaction(super.BuildPartial());} | ||
1338 | public Minitransaction Build() {if (_HasAllPBJFields) return new Minitransaction(super.Build());return null;} | ||
1339 | public pbd::MessageDescriptor DescriptorForType { | ||
1340 | get { return Minitransaction.Descriptor; } } | ||
1341 | public Builder ClearReads() { super.ClearReads();return this;} | ||
1342 | public Builder SetReads(int index,StorageElement value) { | ||
1343 | super.SetReads(index,value._PBJSuper); | ||
1344 | return this; | ||
1345 | } | ||
1346 | public const int ReadsFieldTag=9; | ||
1347 | public int ReadsCount { get { return super.ReadsCount;} } | ||
1348 | public bool HasReads(int index) {return true;} | ||
1349 | public StorageElement Reads(int index) { | ||
1350 | return new StorageElement(super.GetReads(index)); | ||
1351 | } | ||
1352 | public Builder AddReads(StorageElement value) { | ||
1353 | super.AddReads(value._PBJSuper); | ||
1354 | return this; | ||
1355 | } | ||
1356 | public Builder ClearWrites() { super.ClearWrites();return this;} | ||
1357 | public Builder SetWrites(int index,StorageElement value) { | ||
1358 | super.SetWrites(index,value._PBJSuper); | ||
1359 | return this; | ||
1360 | } | ||
1361 | public const int WritesFieldTag=10; | ||
1362 | public int WritesCount { get { return super.WritesCount;} } | ||
1363 | public bool HasWrites(int index) {return true;} | ||
1364 | public StorageElement Writes(int index) { | ||
1365 | return new StorageElement(super.GetWrites(index)); | ||
1366 | } | ||
1367 | public Builder AddWrites(StorageElement value) { | ||
1368 | super.AddWrites(value._PBJSuper); | ||
1369 | return this; | ||
1370 | } | ||
1371 | public Builder ClearCompares() { super.ClearCompares();return this;} | ||
1372 | public Builder SetCompares(int index,CompareElement value) { | ||
1373 | super.SetCompares(index,value._PBJSuper); | ||
1374 | return this; | ||
1375 | } | ||
1376 | public const int ComparesFieldTag=11; | ||
1377 | public int ComparesCount { get { return super.ComparesCount;} } | ||
1378 | public bool HasCompares(int index) {return true;} | ||
1379 | public CompareElement Compares(int index) { | ||
1380 | return new CompareElement(super.GetCompares(index)); | ||
1381 | } | ||
1382 | public Builder AddCompares(CompareElement value) { | ||
1383 | super.AddCompares(value._PBJSuper); | ||
1384 | return this; | ||
1385 | } | ||
1386 | public Builder ClearOptions() { super.ClearOptions();return this;} | ||
1387 | public const int OptionsFieldTag=14; | ||
1388 | public bool HasOptions { get { | ||
1389 | if (!super.HasOptions) return false; | ||
1390 | return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); | ||
1391 | } } | ||
1392 | public ulong Options{ get { | ||
1393 | if (HasOptions) { | ||
1394 | return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES); | ||
1395 | } else { | ||
1396 | return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES); | ||
1397 | } | ||
1398 | } | ||
1399 | set { | ||
1400 | super.Options=((value)); | ||
1401 | } | ||
1402 | } | ||
1403 | } | ||
1404 | } | ||
1405 | } | ||
1406 | namespace Sirikata.Persistence.Protocol { | ||
1407 | public class Response : PBJ.IMessage { | ||
1408 | protected _PBJ_Internal.Response super; | ||
1409 | public _PBJ_Internal.Response _PBJSuper{ get { return super;} } | ||
1410 | public Response() { | ||
1411 | super=new _PBJ_Internal.Response(); | ||
1412 | } | ||
1413 | public Response(_PBJ_Internal.Response reference) { | ||
1414 | super=reference; | ||
1415 | } | ||
1416 | public static Response defaultInstance= new Response (_PBJ_Internal.Response.DefaultInstance); | ||
1417 | public static Response DefaultInstance{ | ||
1418 | get {return defaultInstance;} | ||
1419 | } | ||
1420 | public static pbd.MessageDescriptor Descriptor { | ||
1421 | get { return _PBJ_Internal.Response.Descriptor; } } | ||
1422 | public static class Types { | ||
1423 | public enum ReturnStatus { | ||
1424 | SUCCESS=_PBJ_Internal.Response.Types.ReturnStatus.SUCCESS, | ||
1425 | DATABASE_LOCKED=_PBJ_Internal.Response.Types.ReturnStatus.DATABASE_LOCKED, | ||
1426 | KEY_MISSING=_PBJ_Internal.Response.Types.ReturnStatus.KEY_MISSING, | ||
1427 | COMPARISON_FAILED=_PBJ_Internal.Response.Types.ReturnStatus.COMPARISON_FAILED, | ||
1428 | INTERNAL_ERROR=_PBJ_Internal.Response.Types.ReturnStatus.INTERNAL_ERROR | ||
1429 | }; | ||
1430 | } | ||
1431 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1432 | return false||(field_tag>=1&&field_tag<=8); | ||
1433 | } | ||
1434 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1435 | return false; | ||
1436 | } | ||
1437 | public const int ReadsFieldTag=9; | ||
1438 | public int ReadsCount { get { return super.ReadsCount;} } | ||
1439 | public bool HasReads(int index) {return true;} | ||
1440 | public StorageElement Reads(int index) { | ||
1441 | return new StorageElement(super.GetReads(index)); | ||
1442 | } | ||
1443 | public const int ReturnStatusFieldTag=15; | ||
1444 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
1445 | public Types.ReturnStatus ReturnStatus{ get { | ||
1446 | if (HasReturnStatus) { | ||
1447 | return (Types.ReturnStatus)super.ReturnStatus; | ||
1448 | } else { | ||
1449 | return new Types.ReturnStatus(); | ||
1450 | } | ||
1451 | } | ||
1452 | } | ||
1453 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1454 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1455 | public static Builder CreateBuilder() { return new Builder(); } | ||
1456 | public static Builder CreateBuilder(Response prototype) { | ||
1457 | return (Builder)new Builder().MergeFrom(prototype); | ||
1458 | } | ||
1459 | public static Response ParseFrom(pb::ByteString data) { | ||
1460 | return new Response(_PBJ_Internal.Response.ParseFrom(data)); | ||
1461 | } | ||
1462 | public static Response ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1463 | return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); | ||
1464 | } | ||
1465 | public static Response ParseFrom(byte[] data) { | ||
1466 | return new Response(_PBJ_Internal.Response.ParseFrom(data)); | ||
1467 | } | ||
1468 | public static Response ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1469 | return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); | ||
1470 | } | ||
1471 | public static Response ParseFrom(global::System.IO.Stream data) { | ||
1472 | return new Response(_PBJ_Internal.Response.ParseFrom(data)); | ||
1473 | } | ||
1474 | public static Response ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1475 | return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); | ||
1476 | } | ||
1477 | public static Response ParseFrom(pb::CodedInputStream data) { | ||
1478 | return new Response(_PBJ_Internal.Response.ParseFrom(data)); | ||
1479 | } | ||
1480 | public static Response ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1481 | return new Response(_PBJ_Internal.Response.ParseFrom(data,er)); | ||
1482 | } | ||
1483 | protected override bool _HasAllPBJFields{ get { | ||
1484 | return true | ||
1485 | ; | ||
1486 | } } | ||
1487 | public bool IsInitialized { get { | ||
1488 | return super.IsInitialized&&_HasAllPBJFields; | ||
1489 | } } | ||
1490 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1491 | protected override bool _HasAllPBJFields{ get { | ||
1492 | return true | ||
1493 | ; | ||
1494 | } } | ||
1495 | public bool IsInitialized { get { | ||
1496 | return super.IsInitialized&&_HasAllPBJFields; | ||
1497 | } } | ||
1498 | protected _PBJ_Internal.Response.Builder super; | ||
1499 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1500 | public _PBJ_Internal.Response.Builder _PBJSuper{ get { return super;} } | ||
1501 | public Builder() {super = new _PBJ_Internal.Response.Builder();} | ||
1502 | public Builder(_PBJ_Internal.Response.Builder other) { | ||
1503 | super=other; | ||
1504 | } | ||
1505 | public Builder Clone() {return new Builder(super.Clone());} | ||
1506 | public Builder MergeFrom(Response prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1507 | public Builder Clear() {super.Clear();return this;} | ||
1508 | public Response BuildPartial() {return new Response(super.BuildPartial());} | ||
1509 | public Response Build() {if (_HasAllPBJFields) return new Response(super.Build());return null;} | ||
1510 | public pbd::MessageDescriptor DescriptorForType { | ||
1511 | get { return Response.Descriptor; } } | ||
1512 | public Builder ClearReads() { super.ClearReads();return this;} | ||
1513 | public Builder SetReads(int index,StorageElement value) { | ||
1514 | super.SetReads(index,value._PBJSuper); | ||
1515 | return this; | ||
1516 | } | ||
1517 | public const int ReadsFieldTag=9; | ||
1518 | public int ReadsCount { get { return super.ReadsCount;} } | ||
1519 | public bool HasReads(int index) {return true;} | ||
1520 | public StorageElement Reads(int index) { | ||
1521 | return new StorageElement(super.GetReads(index)); | ||
1522 | } | ||
1523 | public Builder AddReads(StorageElement value) { | ||
1524 | super.AddReads(value._PBJSuper); | ||
1525 | return this; | ||
1526 | } | ||
1527 | public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} | ||
1528 | public const int ReturnStatusFieldTag=15; | ||
1529 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
1530 | public Types.ReturnStatus ReturnStatus{ get { | ||
1531 | if (HasReturnStatus) { | ||
1532 | return (Types.ReturnStatus)super.ReturnStatus; | ||
1533 | } else { | ||
1534 | return new Types.ReturnStatus(); | ||
1535 | } | ||
1536 | } | ||
1537 | set { | ||
1538 | super.ReturnStatus=((_PBJ_Internal.Response.Types.ReturnStatus)value); | ||
1539 | } | ||
1540 | } | ||
1541 | } | ||
1542 | } | ||
1543 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Physics.cs b/OpenSim/Client/Sirikata/Protocol/Physics.cs deleted file mode 100644 index a81a6fd..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Physics.cs +++ /dev/null | |||
@@ -1,840 +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.Physics.Protocol._PBJ_Internal { | ||
8 | |||
9 | public static partial class Physics { | ||
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_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor; | ||
17 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.Builder> internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable; | ||
18 | internal static pbd::MessageDescriptor internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor; | ||
19 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.Builder> internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable; | ||
20 | #endregion | ||
21 | #region Descriptor | ||
22 | public static pbd::FileDescriptor Descriptor { | ||
23 | get { return descriptor; } | ||
24 | } | ||
25 | private static pbd::FileDescriptor descriptor; | ||
26 | |||
27 | static Physics() { | ||
28 | byte[] descriptorData = global::System.Convert.FromBase64String( | ||
29 | "Cg1QaHlzaWNzLnByb3RvEidTaXJpa2F0YS5QaHlzaWNzLlByb3RvY29sLl9Q" + | ||
30 | "QkpfSW50ZXJuYWwiqAEKDkNvbGxpc2lvbkJlZ2luEhEKCXRpbWVzdGFtcBgC" + | ||
31 | "IAEoBhIZCg10aGlzX3Bvc2l0aW9uGAMgAygBQgIQARIaCg5vdGhlcl9wb3Np" + | ||
32 | "dGlvbhgEIAMoAUICEAESFwoLdGhpc19ub3JtYWwYBSADKAJCAhABEhMKB2lt" + | ||
33 | "cHVsc2UYBiADKAJCAhABEh4KFm90aGVyX29iamVjdF9yZWZlcmVuY2UYByAB" + | ||
34 | "KAwiQQoMQ29sbGlzaW9uRW5kEhEKCXRpbWVzdGFtcBgCIAEoBhIeChZvdGhl" + | ||
35 | "cl9vYmplY3RfcmVmZXJlbmNlGAYgASgM"); | ||
36 | pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | ||
37 | descriptor = root; | ||
38 | internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor = Descriptor.MessageTypes[0]; | ||
39 | internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable = | ||
40 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.Builder>(internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor, | ||
41 | new string[] { "Timestamp", "ThisPosition", "OtherPosition", "ThisNormal", "Impulse", "OtherObjectReference", }); | ||
42 | internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor = Descriptor.MessageTypes[1]; | ||
43 | internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable = | ||
44 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd, global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.Builder>(internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor, | ||
45 | new string[] { "Timestamp", "OtherObjectReference", }); | ||
46 | return null; | ||
47 | }; | ||
48 | pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | ||
49 | new pbd::FileDescriptor[] { | ||
50 | }, assigner); | ||
51 | } | ||
52 | #endregion | ||
53 | |||
54 | } | ||
55 | #region Messages | ||
56 | public sealed partial class CollisionBegin : pb::GeneratedMessage<CollisionBegin, CollisionBegin.Builder> { | ||
57 | private static readonly CollisionBegin defaultInstance = new Builder().BuildPartial(); | ||
58 | public static CollisionBegin DefaultInstance { | ||
59 | get { return defaultInstance; } | ||
60 | } | ||
61 | |||
62 | public override CollisionBegin DefaultInstanceForType { | ||
63 | get { return defaultInstance; } | ||
64 | } | ||
65 | |||
66 | protected override CollisionBegin ThisMessage { | ||
67 | get { return this; } | ||
68 | } | ||
69 | |||
70 | public static pbd::MessageDescriptor Descriptor { | ||
71 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__Descriptor; } | ||
72 | } | ||
73 | |||
74 | protected override pb::FieldAccess.FieldAccessorTable<CollisionBegin, CollisionBegin.Builder> InternalFieldAccessors { | ||
75 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionBegin__FieldAccessorTable; } | ||
76 | } | ||
77 | |||
78 | public const int TimestampFieldNumber = 2; | ||
79 | private bool hasTimestamp; | ||
80 | private ulong timestamp_ = 0; | ||
81 | public bool HasTimestamp { | ||
82 | get { return hasTimestamp; } | ||
83 | } | ||
84 | [global::System.CLSCompliant(false)] | ||
85 | public ulong Timestamp { | ||
86 | get { return timestamp_; } | ||
87 | } | ||
88 | |||
89 | public const int ThisPositionFieldNumber = 3; | ||
90 | private int thisPositionMemoizedSerializedSize; | ||
91 | private pbc::PopsicleList<double> thisPosition_ = new pbc::PopsicleList<double>(); | ||
92 | public scg::IList<double> ThisPositionList { | ||
93 | get { return pbc::Lists.AsReadOnly(thisPosition_); } | ||
94 | } | ||
95 | public int ThisPositionCount { | ||
96 | get { return thisPosition_.Count; } | ||
97 | } | ||
98 | public double GetThisPosition(int index) { | ||
99 | return thisPosition_[index]; | ||
100 | } | ||
101 | |||
102 | public const int OtherPositionFieldNumber = 4; | ||
103 | private int otherPositionMemoizedSerializedSize; | ||
104 | private pbc::PopsicleList<double> otherPosition_ = new pbc::PopsicleList<double>(); | ||
105 | public scg::IList<double> OtherPositionList { | ||
106 | get { return pbc::Lists.AsReadOnly(otherPosition_); } | ||
107 | } | ||
108 | public int OtherPositionCount { | ||
109 | get { return otherPosition_.Count; } | ||
110 | } | ||
111 | public double GetOtherPosition(int index) { | ||
112 | return otherPosition_[index]; | ||
113 | } | ||
114 | |||
115 | public const int ThisNormalFieldNumber = 5; | ||
116 | private int thisNormalMemoizedSerializedSize; | ||
117 | private pbc::PopsicleList<float> thisNormal_ = new pbc::PopsicleList<float>(); | ||
118 | public scg::IList<float> ThisNormalList { | ||
119 | get { return pbc::Lists.AsReadOnly(thisNormal_); } | ||
120 | } | ||
121 | public int ThisNormalCount { | ||
122 | get { return thisNormal_.Count; } | ||
123 | } | ||
124 | public float GetThisNormal(int index) { | ||
125 | return thisNormal_[index]; | ||
126 | } | ||
127 | |||
128 | public const int ImpulseFieldNumber = 6; | ||
129 | private int impulseMemoizedSerializedSize; | ||
130 | private pbc::PopsicleList<float> impulse_ = new pbc::PopsicleList<float>(); | ||
131 | public scg::IList<float> ImpulseList { | ||
132 | get { return pbc::Lists.AsReadOnly(impulse_); } | ||
133 | } | ||
134 | public int ImpulseCount { | ||
135 | get { return impulse_.Count; } | ||
136 | } | ||
137 | public float GetImpulse(int index) { | ||
138 | return impulse_[index]; | ||
139 | } | ||
140 | |||
141 | public const int OtherObjectReferenceFieldNumber = 7; | ||
142 | private bool hasOtherObjectReference; | ||
143 | private pb::ByteString otherObjectReference_ = pb::ByteString.Empty; | ||
144 | public bool HasOtherObjectReference { | ||
145 | get { return hasOtherObjectReference; } | ||
146 | } | ||
147 | public pb::ByteString OtherObjectReference { | ||
148 | get { return otherObjectReference_; } | ||
149 | } | ||
150 | |||
151 | public override bool IsInitialized { | ||
152 | get { | ||
153 | return true; | ||
154 | } | ||
155 | } | ||
156 | |||
157 | public override void WriteTo(pb::CodedOutputStream output) { | ||
158 | if (HasTimestamp) { | ||
159 | output.WriteFixed64(2, Timestamp); | ||
160 | } | ||
161 | if (thisPosition_.Count > 0) { | ||
162 | output.WriteRawVarint32(26); | ||
163 | output.WriteRawVarint32((uint) thisPositionMemoizedSerializedSize); | ||
164 | foreach (double element in thisPosition_) { | ||
165 | output.WriteDoubleNoTag(element); | ||
166 | } | ||
167 | } | ||
168 | if (otherPosition_.Count > 0) { | ||
169 | output.WriteRawVarint32(34); | ||
170 | output.WriteRawVarint32((uint) otherPositionMemoizedSerializedSize); | ||
171 | foreach (double element in otherPosition_) { | ||
172 | output.WriteDoubleNoTag(element); | ||
173 | } | ||
174 | } | ||
175 | if (thisNormal_.Count > 0) { | ||
176 | output.WriteRawVarint32(42); | ||
177 | output.WriteRawVarint32((uint) thisNormalMemoizedSerializedSize); | ||
178 | foreach (float element in thisNormal_) { | ||
179 | output.WriteFloatNoTag(element); | ||
180 | } | ||
181 | } | ||
182 | if (impulse_.Count > 0) { | ||
183 | output.WriteRawVarint32(50); | ||
184 | output.WriteRawVarint32((uint) impulseMemoizedSerializedSize); | ||
185 | foreach (float element in impulse_) { | ||
186 | output.WriteFloatNoTag(element); | ||
187 | } | ||
188 | } | ||
189 | if (HasOtherObjectReference) { | ||
190 | output.WriteBytes(7, OtherObjectReference); | ||
191 | } | ||
192 | UnknownFields.WriteTo(output); | ||
193 | } | ||
194 | |||
195 | private int memoizedSerializedSize = -1; | ||
196 | public override int SerializedSize { | ||
197 | get { | ||
198 | int size = memoizedSerializedSize; | ||
199 | if (size != -1) return size; | ||
200 | |||
201 | size = 0; | ||
202 | if (HasTimestamp) { | ||
203 | size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp); | ||
204 | } | ||
205 | { | ||
206 | int dataSize = 0; | ||
207 | dataSize = 8 * thisPosition_.Count; | ||
208 | size += dataSize; | ||
209 | if (thisPosition_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
210 | thisPositionMemoizedSerializedSize = dataSize; | ||
211 | } | ||
212 | { | ||
213 | int dataSize = 0; | ||
214 | dataSize = 8 * otherPosition_.Count; | ||
215 | size += dataSize; | ||
216 | if (otherPosition_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
217 | otherPositionMemoizedSerializedSize = dataSize; | ||
218 | } | ||
219 | { | ||
220 | int dataSize = 0; | ||
221 | dataSize = 4 * thisNormal_.Count; | ||
222 | size += dataSize; | ||
223 | if (thisNormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
224 | thisNormalMemoizedSerializedSize = dataSize; | ||
225 | } | ||
226 | { | ||
227 | int dataSize = 0; | ||
228 | dataSize = 4 * impulse_.Count; | ||
229 | size += dataSize; | ||
230 | if (impulse_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
231 | impulseMemoizedSerializedSize = dataSize; | ||
232 | } | ||
233 | if (HasOtherObjectReference) { | ||
234 | size += pb::CodedOutputStream.ComputeBytesSize(7, OtherObjectReference); | ||
235 | } | ||
236 | size += UnknownFields.SerializedSize; | ||
237 | memoizedSerializedSize = size; | ||
238 | return size; | ||
239 | } | ||
240 | } | ||
241 | |||
242 | public static CollisionBegin ParseFrom(pb::ByteString data) { | ||
243 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
244 | } | ||
245 | public static CollisionBegin ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
246 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
247 | } | ||
248 | public static CollisionBegin ParseFrom(byte[] data) { | ||
249 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
250 | } | ||
251 | public static CollisionBegin ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
252 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
253 | } | ||
254 | public static CollisionBegin ParseFrom(global::System.IO.Stream input) { | ||
255 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
256 | } | ||
257 | public static CollisionBegin ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
258 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
259 | } | ||
260 | public static CollisionBegin ParseDelimitedFrom(global::System.IO.Stream input) { | ||
261 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
262 | } | ||
263 | public static CollisionBegin ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
264 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
265 | } | ||
266 | public static CollisionBegin ParseFrom(pb::CodedInputStream input) { | ||
267 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
268 | } | ||
269 | public static CollisionBegin ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
270 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
271 | } | ||
272 | public static Builder CreateBuilder() { return new Builder(); } | ||
273 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
274 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
275 | public static Builder CreateBuilder(CollisionBegin prototype) { | ||
276 | return (Builder) new Builder().MergeFrom(prototype); | ||
277 | } | ||
278 | |||
279 | public sealed partial class Builder : pb::GeneratedBuilder<CollisionBegin, Builder> { | ||
280 | protected override Builder ThisBuilder { | ||
281 | get { return this; } | ||
282 | } | ||
283 | public Builder() {} | ||
284 | |||
285 | CollisionBegin result = new CollisionBegin(); | ||
286 | |||
287 | protected override CollisionBegin MessageBeingBuilt { | ||
288 | get { return result; } | ||
289 | } | ||
290 | |||
291 | public override Builder Clear() { | ||
292 | result = new CollisionBegin(); | ||
293 | return this; | ||
294 | } | ||
295 | |||
296 | public override Builder Clone() { | ||
297 | return new Builder().MergeFrom(result); | ||
298 | } | ||
299 | |||
300 | public override pbd::MessageDescriptor DescriptorForType { | ||
301 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.Descriptor; } | ||
302 | } | ||
303 | |||
304 | public override CollisionBegin DefaultInstanceForType { | ||
305 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.DefaultInstance; } | ||
306 | } | ||
307 | |||
308 | public override CollisionBegin BuildPartial() { | ||
309 | if (result == null) { | ||
310 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
311 | } | ||
312 | result.thisPosition_.MakeReadOnly(); | ||
313 | result.otherPosition_.MakeReadOnly(); | ||
314 | result.thisNormal_.MakeReadOnly(); | ||
315 | result.impulse_.MakeReadOnly(); | ||
316 | CollisionBegin returnMe = result; | ||
317 | result = null; | ||
318 | return returnMe; | ||
319 | } | ||
320 | |||
321 | public override Builder MergeFrom(pb::IMessage other) { | ||
322 | if (other is CollisionBegin) { | ||
323 | return MergeFrom((CollisionBegin) other); | ||
324 | } else { | ||
325 | base.MergeFrom(other); | ||
326 | return this; | ||
327 | } | ||
328 | } | ||
329 | |||
330 | public override Builder MergeFrom(CollisionBegin other) { | ||
331 | if (other == global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionBegin.DefaultInstance) return this; | ||
332 | if (other.HasTimestamp) { | ||
333 | Timestamp = other.Timestamp; | ||
334 | } | ||
335 | if (other.thisPosition_.Count != 0) { | ||
336 | base.AddRange(other.thisPosition_, result.thisPosition_); | ||
337 | } | ||
338 | if (other.otherPosition_.Count != 0) { | ||
339 | base.AddRange(other.otherPosition_, result.otherPosition_); | ||
340 | } | ||
341 | if (other.thisNormal_.Count != 0) { | ||
342 | base.AddRange(other.thisNormal_, result.thisNormal_); | ||
343 | } | ||
344 | if (other.impulse_.Count != 0) { | ||
345 | base.AddRange(other.impulse_, result.impulse_); | ||
346 | } | ||
347 | if (other.HasOtherObjectReference) { | ||
348 | OtherObjectReference = other.OtherObjectReference; | ||
349 | } | ||
350 | this.MergeUnknownFields(other.UnknownFields); | ||
351 | return this; | ||
352 | } | ||
353 | |||
354 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
355 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
356 | } | ||
357 | |||
358 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
359 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
360 | while (true) { | ||
361 | uint tag = input.ReadTag(); | ||
362 | switch (tag) { | ||
363 | case 0: { | ||
364 | if (unknownFields != null) { | ||
365 | this.UnknownFields = unknownFields.Build(); | ||
366 | } | ||
367 | return this; | ||
368 | } | ||
369 | default: { | ||
370 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
371 | if (unknownFields != null) { | ||
372 | this.UnknownFields = unknownFields.Build(); | ||
373 | } | ||
374 | return this; | ||
375 | } | ||
376 | if (unknownFields == null) { | ||
377 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
378 | } | ||
379 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
380 | break; | ||
381 | } | ||
382 | case 17: { | ||
383 | Timestamp = input.ReadFixed64(); | ||
384 | break; | ||
385 | } | ||
386 | case 26: { | ||
387 | int length = input.ReadInt32(); | ||
388 | int limit = input.PushLimit(length); | ||
389 | while (!input.ReachedLimit) { | ||
390 | AddThisPosition(input.ReadDouble()); | ||
391 | } | ||
392 | input.PopLimit(limit); | ||
393 | break; | ||
394 | } | ||
395 | case 34: { | ||
396 | int length = input.ReadInt32(); | ||
397 | int limit = input.PushLimit(length); | ||
398 | while (!input.ReachedLimit) { | ||
399 | AddOtherPosition(input.ReadDouble()); | ||
400 | } | ||
401 | input.PopLimit(limit); | ||
402 | break; | ||
403 | } | ||
404 | case 42: { | ||
405 | int length = input.ReadInt32(); | ||
406 | int limit = input.PushLimit(length); | ||
407 | while (!input.ReachedLimit) { | ||
408 | AddThisNormal(input.ReadFloat()); | ||
409 | } | ||
410 | input.PopLimit(limit); | ||
411 | break; | ||
412 | } | ||
413 | case 50: { | ||
414 | int length = input.ReadInt32(); | ||
415 | int limit = input.PushLimit(length); | ||
416 | while (!input.ReachedLimit) { | ||
417 | AddImpulse(input.ReadFloat()); | ||
418 | } | ||
419 | input.PopLimit(limit); | ||
420 | break; | ||
421 | } | ||
422 | case 58: { | ||
423 | OtherObjectReference = input.ReadBytes(); | ||
424 | break; | ||
425 | } | ||
426 | } | ||
427 | } | ||
428 | } | ||
429 | |||
430 | |||
431 | public bool HasTimestamp { | ||
432 | get { return result.HasTimestamp; } | ||
433 | } | ||
434 | [global::System.CLSCompliant(false)] | ||
435 | public ulong Timestamp { | ||
436 | get { return result.Timestamp; } | ||
437 | set { SetTimestamp(value); } | ||
438 | } | ||
439 | [global::System.CLSCompliant(false)] | ||
440 | public Builder SetTimestamp(ulong value) { | ||
441 | result.hasTimestamp = true; | ||
442 | result.timestamp_ = value; | ||
443 | return this; | ||
444 | } | ||
445 | public Builder ClearTimestamp() { | ||
446 | result.hasTimestamp = false; | ||
447 | result.timestamp_ = 0; | ||
448 | return this; | ||
449 | } | ||
450 | |||
451 | public pbc::IPopsicleList<double> ThisPositionList { | ||
452 | get { return result.thisPosition_; } | ||
453 | } | ||
454 | public int ThisPositionCount { | ||
455 | get { return result.ThisPositionCount; } | ||
456 | } | ||
457 | public double GetThisPosition(int index) { | ||
458 | return result.GetThisPosition(index); | ||
459 | } | ||
460 | public Builder SetThisPosition(int index, double value) { | ||
461 | result.thisPosition_[index] = value; | ||
462 | return this; | ||
463 | } | ||
464 | public Builder AddThisPosition(double value) { | ||
465 | result.thisPosition_.Add(value); | ||
466 | return this; | ||
467 | } | ||
468 | public Builder AddRangeThisPosition(scg::IEnumerable<double> values) { | ||
469 | base.AddRange(values, result.thisPosition_); | ||
470 | return this; | ||
471 | } | ||
472 | public Builder ClearThisPosition() { | ||
473 | result.thisPosition_.Clear(); | ||
474 | return this; | ||
475 | } | ||
476 | |||
477 | public pbc::IPopsicleList<double> OtherPositionList { | ||
478 | get { return result.otherPosition_; } | ||
479 | } | ||
480 | public int OtherPositionCount { | ||
481 | get { return result.OtherPositionCount; } | ||
482 | } | ||
483 | public double GetOtherPosition(int index) { | ||
484 | return result.GetOtherPosition(index); | ||
485 | } | ||
486 | public Builder SetOtherPosition(int index, double value) { | ||
487 | result.otherPosition_[index] = value; | ||
488 | return this; | ||
489 | } | ||
490 | public Builder AddOtherPosition(double value) { | ||
491 | result.otherPosition_.Add(value); | ||
492 | return this; | ||
493 | } | ||
494 | public Builder AddRangeOtherPosition(scg::IEnumerable<double> values) { | ||
495 | base.AddRange(values, result.otherPosition_); | ||
496 | return this; | ||
497 | } | ||
498 | public Builder ClearOtherPosition() { | ||
499 | result.otherPosition_.Clear(); | ||
500 | return this; | ||
501 | } | ||
502 | |||
503 | public pbc::IPopsicleList<float> ThisNormalList { | ||
504 | get { return result.thisNormal_; } | ||
505 | } | ||
506 | public int ThisNormalCount { | ||
507 | get { return result.ThisNormalCount; } | ||
508 | } | ||
509 | public float GetThisNormal(int index) { | ||
510 | return result.GetThisNormal(index); | ||
511 | } | ||
512 | public Builder SetThisNormal(int index, float value) { | ||
513 | result.thisNormal_[index] = value; | ||
514 | return this; | ||
515 | } | ||
516 | public Builder AddThisNormal(float value) { | ||
517 | result.thisNormal_.Add(value); | ||
518 | return this; | ||
519 | } | ||
520 | public Builder AddRangeThisNormal(scg::IEnumerable<float> values) { | ||
521 | base.AddRange(values, result.thisNormal_); | ||
522 | return this; | ||
523 | } | ||
524 | public Builder ClearThisNormal() { | ||
525 | result.thisNormal_.Clear(); | ||
526 | return this; | ||
527 | } | ||
528 | |||
529 | public pbc::IPopsicleList<float> ImpulseList { | ||
530 | get { return result.impulse_; } | ||
531 | } | ||
532 | public int ImpulseCount { | ||
533 | get { return result.ImpulseCount; } | ||
534 | } | ||
535 | public float GetImpulse(int index) { | ||
536 | return result.GetImpulse(index); | ||
537 | } | ||
538 | public Builder SetImpulse(int index, float value) { | ||
539 | result.impulse_[index] = value; | ||
540 | return this; | ||
541 | } | ||
542 | public Builder AddImpulse(float value) { | ||
543 | result.impulse_.Add(value); | ||
544 | return this; | ||
545 | } | ||
546 | public Builder AddRangeImpulse(scg::IEnumerable<float> values) { | ||
547 | base.AddRange(values, result.impulse_); | ||
548 | return this; | ||
549 | } | ||
550 | public Builder ClearImpulse() { | ||
551 | result.impulse_.Clear(); | ||
552 | return this; | ||
553 | } | ||
554 | |||
555 | public bool HasOtherObjectReference { | ||
556 | get { return result.HasOtherObjectReference; } | ||
557 | } | ||
558 | public pb::ByteString OtherObjectReference { | ||
559 | get { return result.OtherObjectReference; } | ||
560 | set { SetOtherObjectReference(value); } | ||
561 | } | ||
562 | public Builder SetOtherObjectReference(pb::ByteString value) { | ||
563 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
564 | result.hasOtherObjectReference = true; | ||
565 | result.otherObjectReference_ = value; | ||
566 | return this; | ||
567 | } | ||
568 | public Builder ClearOtherObjectReference() { | ||
569 | result.hasOtherObjectReference = false; | ||
570 | result.otherObjectReference_ = pb::ByteString.Empty; | ||
571 | return this; | ||
572 | } | ||
573 | } | ||
574 | static CollisionBegin() { | ||
575 | object.ReferenceEquals(global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.Descriptor, null); | ||
576 | } | ||
577 | } | ||
578 | |||
579 | public sealed partial class CollisionEnd : pb::GeneratedMessage<CollisionEnd, CollisionEnd.Builder> { | ||
580 | private static readonly CollisionEnd defaultInstance = new Builder().BuildPartial(); | ||
581 | public static CollisionEnd DefaultInstance { | ||
582 | get { return defaultInstance; } | ||
583 | } | ||
584 | |||
585 | public override CollisionEnd DefaultInstanceForType { | ||
586 | get { return defaultInstance; } | ||
587 | } | ||
588 | |||
589 | protected override CollisionEnd ThisMessage { | ||
590 | get { return this; } | ||
591 | } | ||
592 | |||
593 | public static pbd::MessageDescriptor Descriptor { | ||
594 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__Descriptor; } | ||
595 | } | ||
596 | |||
597 | protected override pb::FieldAccess.FieldAccessorTable<CollisionEnd, CollisionEnd.Builder> InternalFieldAccessors { | ||
598 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.internal__static_Sirikata_Physics_Protocol__PBJ_Internal_CollisionEnd__FieldAccessorTable; } | ||
599 | } | ||
600 | |||
601 | public const int TimestampFieldNumber = 2; | ||
602 | private bool hasTimestamp; | ||
603 | private ulong timestamp_ = 0; | ||
604 | public bool HasTimestamp { | ||
605 | get { return hasTimestamp; } | ||
606 | } | ||
607 | [global::System.CLSCompliant(false)] | ||
608 | public ulong Timestamp { | ||
609 | get { return timestamp_; } | ||
610 | } | ||
611 | |||
612 | public const int OtherObjectReferenceFieldNumber = 6; | ||
613 | private bool hasOtherObjectReference; | ||
614 | private pb::ByteString otherObjectReference_ = pb::ByteString.Empty; | ||
615 | public bool HasOtherObjectReference { | ||
616 | get { return hasOtherObjectReference; } | ||
617 | } | ||
618 | public pb::ByteString OtherObjectReference { | ||
619 | get { return otherObjectReference_; } | ||
620 | } | ||
621 | |||
622 | public override bool IsInitialized { | ||
623 | get { | ||
624 | return true; | ||
625 | } | ||
626 | } | ||
627 | |||
628 | public override void WriteTo(pb::CodedOutputStream output) { | ||
629 | if (HasTimestamp) { | ||
630 | output.WriteFixed64(2, Timestamp); | ||
631 | } | ||
632 | if (HasOtherObjectReference) { | ||
633 | output.WriteBytes(6, OtherObjectReference); | ||
634 | } | ||
635 | UnknownFields.WriteTo(output); | ||
636 | } | ||
637 | |||
638 | private int memoizedSerializedSize = -1; | ||
639 | public override int SerializedSize { | ||
640 | get { | ||
641 | int size = memoizedSerializedSize; | ||
642 | if (size != -1) return size; | ||
643 | |||
644 | size = 0; | ||
645 | if (HasTimestamp) { | ||
646 | size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp); | ||
647 | } | ||
648 | if (HasOtherObjectReference) { | ||
649 | size += pb::CodedOutputStream.ComputeBytesSize(6, OtherObjectReference); | ||
650 | } | ||
651 | size += UnknownFields.SerializedSize; | ||
652 | memoizedSerializedSize = size; | ||
653 | return size; | ||
654 | } | ||
655 | } | ||
656 | |||
657 | public static CollisionEnd ParseFrom(pb::ByteString data) { | ||
658 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
659 | } | ||
660 | public static CollisionEnd ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
661 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
662 | } | ||
663 | public static CollisionEnd ParseFrom(byte[] data) { | ||
664 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
665 | } | ||
666 | public static CollisionEnd ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
667 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
668 | } | ||
669 | public static CollisionEnd ParseFrom(global::System.IO.Stream input) { | ||
670 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
671 | } | ||
672 | public static CollisionEnd ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
673 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
674 | } | ||
675 | public static CollisionEnd ParseDelimitedFrom(global::System.IO.Stream input) { | ||
676 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
677 | } | ||
678 | public static CollisionEnd ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
679 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
680 | } | ||
681 | public static CollisionEnd ParseFrom(pb::CodedInputStream input) { | ||
682 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
683 | } | ||
684 | public static CollisionEnd ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
685 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
686 | } | ||
687 | public static Builder CreateBuilder() { return new Builder(); } | ||
688 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
689 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
690 | public static Builder CreateBuilder(CollisionEnd prototype) { | ||
691 | return (Builder) new Builder().MergeFrom(prototype); | ||
692 | } | ||
693 | |||
694 | public sealed partial class Builder : pb::GeneratedBuilder<CollisionEnd, Builder> { | ||
695 | protected override Builder ThisBuilder { | ||
696 | get { return this; } | ||
697 | } | ||
698 | public Builder() {} | ||
699 | |||
700 | CollisionEnd result = new CollisionEnd(); | ||
701 | |||
702 | protected override CollisionEnd MessageBeingBuilt { | ||
703 | get { return result; } | ||
704 | } | ||
705 | |||
706 | public override Builder Clear() { | ||
707 | result = new CollisionEnd(); | ||
708 | return this; | ||
709 | } | ||
710 | |||
711 | public override Builder Clone() { | ||
712 | return new Builder().MergeFrom(result); | ||
713 | } | ||
714 | |||
715 | public override pbd::MessageDescriptor DescriptorForType { | ||
716 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.Descriptor; } | ||
717 | } | ||
718 | |||
719 | public override CollisionEnd DefaultInstanceForType { | ||
720 | get { return global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.DefaultInstance; } | ||
721 | } | ||
722 | |||
723 | public override CollisionEnd BuildPartial() { | ||
724 | if (result == null) { | ||
725 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
726 | } | ||
727 | CollisionEnd returnMe = result; | ||
728 | result = null; | ||
729 | return returnMe; | ||
730 | } | ||
731 | |||
732 | public override Builder MergeFrom(pb::IMessage other) { | ||
733 | if (other is CollisionEnd) { | ||
734 | return MergeFrom((CollisionEnd) other); | ||
735 | } else { | ||
736 | base.MergeFrom(other); | ||
737 | return this; | ||
738 | } | ||
739 | } | ||
740 | |||
741 | public override Builder MergeFrom(CollisionEnd other) { | ||
742 | if (other == global::Sirikata.Physics.Protocol._PBJ_Internal.CollisionEnd.DefaultInstance) return this; | ||
743 | if (other.HasTimestamp) { | ||
744 | Timestamp = other.Timestamp; | ||
745 | } | ||
746 | if (other.HasOtherObjectReference) { | ||
747 | OtherObjectReference = other.OtherObjectReference; | ||
748 | } | ||
749 | this.MergeUnknownFields(other.UnknownFields); | ||
750 | return this; | ||
751 | } | ||
752 | |||
753 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
754 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
755 | } | ||
756 | |||
757 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
758 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
759 | while (true) { | ||
760 | uint tag = input.ReadTag(); | ||
761 | switch (tag) { | ||
762 | case 0: { | ||
763 | if (unknownFields != null) { | ||
764 | this.UnknownFields = unknownFields.Build(); | ||
765 | } | ||
766 | return this; | ||
767 | } | ||
768 | default: { | ||
769 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
770 | if (unknownFields != null) { | ||
771 | this.UnknownFields = unknownFields.Build(); | ||
772 | } | ||
773 | return this; | ||
774 | } | ||
775 | if (unknownFields == null) { | ||
776 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
777 | } | ||
778 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
779 | break; | ||
780 | } | ||
781 | case 17: { | ||
782 | Timestamp = input.ReadFixed64(); | ||
783 | break; | ||
784 | } | ||
785 | case 50: { | ||
786 | OtherObjectReference = input.ReadBytes(); | ||
787 | break; | ||
788 | } | ||
789 | } | ||
790 | } | ||
791 | } | ||
792 | |||
793 | |||
794 | public bool HasTimestamp { | ||
795 | get { return result.HasTimestamp; } | ||
796 | } | ||
797 | [global::System.CLSCompliant(false)] | ||
798 | public ulong Timestamp { | ||
799 | get { return result.Timestamp; } | ||
800 | set { SetTimestamp(value); } | ||
801 | } | ||
802 | [global::System.CLSCompliant(false)] | ||
803 | public Builder SetTimestamp(ulong value) { | ||
804 | result.hasTimestamp = true; | ||
805 | result.timestamp_ = value; | ||
806 | return this; | ||
807 | } | ||
808 | public Builder ClearTimestamp() { | ||
809 | result.hasTimestamp = false; | ||
810 | result.timestamp_ = 0; | ||
811 | return this; | ||
812 | } | ||
813 | |||
814 | public bool HasOtherObjectReference { | ||
815 | get { return result.HasOtherObjectReference; } | ||
816 | } | ||
817 | public pb::ByteString OtherObjectReference { | ||
818 | get { return result.OtherObjectReference; } | ||
819 | set { SetOtherObjectReference(value); } | ||
820 | } | ||
821 | public Builder SetOtherObjectReference(pb::ByteString value) { | ||
822 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
823 | result.hasOtherObjectReference = true; | ||
824 | result.otherObjectReference_ = value; | ||
825 | return this; | ||
826 | } | ||
827 | public Builder ClearOtherObjectReference() { | ||
828 | result.hasOtherObjectReference = false; | ||
829 | result.otherObjectReference_ = pb::ByteString.Empty; | ||
830 | return this; | ||
831 | } | ||
832 | } | ||
833 | static CollisionEnd() { | ||
834 | object.ReferenceEquals(global::Sirikata.Physics.Protocol._PBJ_Internal.Physics.Descriptor, null); | ||
835 | } | ||
836 | } | ||
837 | |||
838 | #endregion | ||
839 | |||
840 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs deleted file mode 100644 index 9fb5a28..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs +++ /dev/null | |||
@@ -1,421 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace Sirikata.Physics.Protocol { | ||
31 | public class CollisionBegin : PBJ.IMessage { | ||
32 | protected _PBJ_Internal.CollisionBegin super; | ||
33 | public _PBJ_Internal.CollisionBegin _PBJSuper{ get { return super;} } | ||
34 | public CollisionBegin() { | ||
35 | super=new _PBJ_Internal.CollisionBegin(); | ||
36 | } | ||
37 | public CollisionBegin(_PBJ_Internal.CollisionBegin reference) { | ||
38 | super=reference; | ||
39 | } | ||
40 | public static CollisionBegin defaultInstance= new CollisionBegin (_PBJ_Internal.CollisionBegin.DefaultInstance); | ||
41 | public static CollisionBegin DefaultInstance{ | ||
42 | get {return defaultInstance;} | ||
43 | } | ||
44 | public static pbd.MessageDescriptor Descriptor { | ||
45 | get { return _PBJ_Internal.CollisionBegin.Descriptor; } } | ||
46 | public static class Types { | ||
47 | } | ||
48 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
49 | return false; | ||
50 | } | ||
51 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
52 | return false; | ||
53 | } | ||
54 | public const int TimestampFieldTag=2; | ||
55 | public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } | ||
56 | public PBJ.Time Timestamp{ get { | ||
57 | if (HasTimestamp) { | ||
58 | return PBJ._PBJ.CastTime(super.Timestamp); | ||
59 | } else { | ||
60 | return PBJ._PBJ.CastTime(); | ||
61 | } | ||
62 | } | ||
63 | } | ||
64 | public const int ThisPositionFieldTag=3; | ||
65 | public int ThisPositionCount { get { return super.ThisPositionCount/3;} } | ||
66 | public bool HasThisPosition(int index) { return true; } | ||
67 | public PBJ.Vector3d GetThisPosition(int index) { | ||
68 | if (HasThisPosition(index)) { | ||
69 | return PBJ._PBJ.CastVector3d(super.GetThisPosition(index*3+0),super.GetThisPosition(index*3+1),super.GetThisPosition(index*3+2)); | ||
70 | } else { | ||
71 | return PBJ._PBJ.CastVector3d(); | ||
72 | } | ||
73 | } | ||
74 | public const int OtherPositionFieldTag=4; | ||
75 | public int OtherPositionCount { get { return super.OtherPositionCount/3;} } | ||
76 | public bool HasOtherPosition(int index) { return true; } | ||
77 | public PBJ.Vector3d GetOtherPosition(int index) { | ||
78 | if (HasOtherPosition(index)) { | ||
79 | return PBJ._PBJ.CastVector3d(super.GetOtherPosition(index*3+0),super.GetOtherPosition(index*3+1),super.GetOtherPosition(index*3+2)); | ||
80 | } else { | ||
81 | return PBJ._PBJ.CastVector3d(); | ||
82 | } | ||
83 | } | ||
84 | public const int ThisNormalFieldTag=5; | ||
85 | public int ThisNormalCount { get { return super.ThisNormalCount/2;} } | ||
86 | public bool HasThisNormal(int index) { return true; } | ||
87 | public PBJ.Vector3f GetThisNormal(int index) { | ||
88 | if (HasThisNormal(index)) { | ||
89 | return PBJ._PBJ.CastNormal(super.GetThisNormal(index*2+0),super.GetThisNormal(index*2+1)); | ||
90 | } else { | ||
91 | return PBJ._PBJ.CastNormal(); | ||
92 | } | ||
93 | } | ||
94 | public const int ImpulseFieldTag=6; | ||
95 | public int ImpulseCount { get { return super.ImpulseCount;} } | ||
96 | public bool HasImpulse(int index) {return PBJ._PBJ.ValidateFloat(super.GetImpulse(index));} | ||
97 | public float Impulse(int index) { | ||
98 | return (float)PBJ._PBJ.CastFloat(super.GetImpulse(index)); | ||
99 | } | ||
100 | public const int OtherObjectReferenceFieldTag=7; | ||
101 | public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } | ||
102 | public PBJ.UUID OtherObjectReference{ get { | ||
103 | if (HasOtherObjectReference) { | ||
104 | return PBJ._PBJ.CastUuid(super.OtherObjectReference); | ||
105 | } else { | ||
106 | return PBJ._PBJ.CastUuid(); | ||
107 | } | ||
108 | } | ||
109 | } | ||
110 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
111 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
112 | public static Builder CreateBuilder() { return new Builder(); } | ||
113 | public static Builder CreateBuilder(CollisionBegin prototype) { | ||
114 | return (Builder)new Builder().MergeFrom(prototype); | ||
115 | } | ||
116 | public static CollisionBegin ParseFrom(pb::ByteString data) { | ||
117 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); | ||
118 | } | ||
119 | public static CollisionBegin ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
120 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); | ||
121 | } | ||
122 | public static CollisionBegin ParseFrom(byte[] data) { | ||
123 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); | ||
124 | } | ||
125 | public static CollisionBegin ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
126 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); | ||
127 | } | ||
128 | public static CollisionBegin ParseFrom(global::System.IO.Stream data) { | ||
129 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); | ||
130 | } | ||
131 | public static CollisionBegin ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
132 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); | ||
133 | } | ||
134 | public static CollisionBegin ParseFrom(pb::CodedInputStream data) { | ||
135 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data)); | ||
136 | } | ||
137 | public static CollisionBegin ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
138 | return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er)); | ||
139 | } | ||
140 | protected override bool _HasAllPBJFields{ get { | ||
141 | return true | ||
142 | ; | ||
143 | } } | ||
144 | public bool IsInitialized { get { | ||
145 | return super.IsInitialized&&_HasAllPBJFields; | ||
146 | } } | ||
147 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
148 | protected override bool _HasAllPBJFields{ get { | ||
149 | return true | ||
150 | ; | ||
151 | } } | ||
152 | public bool IsInitialized { get { | ||
153 | return super.IsInitialized&&_HasAllPBJFields; | ||
154 | } } | ||
155 | protected _PBJ_Internal.CollisionBegin.Builder super; | ||
156 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
157 | public _PBJ_Internal.CollisionBegin.Builder _PBJSuper{ get { return super;} } | ||
158 | public Builder() {super = new _PBJ_Internal.CollisionBegin.Builder();} | ||
159 | public Builder(_PBJ_Internal.CollisionBegin.Builder other) { | ||
160 | super=other; | ||
161 | } | ||
162 | public Builder Clone() {return new Builder(super.Clone());} | ||
163 | public Builder MergeFrom(CollisionBegin prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
164 | public Builder Clear() {super.Clear();return this;} | ||
165 | public CollisionBegin BuildPartial() {return new CollisionBegin(super.BuildPartial());} | ||
166 | public CollisionBegin Build() {if (_HasAllPBJFields) return new CollisionBegin(super.Build());return null;} | ||
167 | public pbd::MessageDescriptor DescriptorForType { | ||
168 | get { return CollisionBegin.Descriptor; } } | ||
169 | public Builder ClearTimestamp() { super.ClearTimestamp();return this;} | ||
170 | public const int TimestampFieldTag=2; | ||
171 | public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } | ||
172 | public PBJ.Time Timestamp{ get { | ||
173 | if (HasTimestamp) { | ||
174 | return PBJ._PBJ.CastTime(super.Timestamp); | ||
175 | } else { | ||
176 | return PBJ._PBJ.CastTime(); | ||
177 | } | ||
178 | } | ||
179 | set { | ||
180 | super.Timestamp=(PBJ._PBJ.Construct(value)); | ||
181 | } | ||
182 | } | ||
183 | public Builder ClearThisPosition() { super.ClearThisPosition();return this;} | ||
184 | public const int ThisPositionFieldTag=3; | ||
185 | public int ThisPositionCount { get { return super.ThisPositionCount/3;} } | ||
186 | public bool HasThisPosition(int index) { return true; } | ||
187 | public PBJ.Vector3d GetThisPosition(int index) { | ||
188 | if (HasThisPosition(index)) { | ||
189 | return PBJ._PBJ.CastVector3d(super.GetThisPosition(index*3+0),super.GetThisPosition(index*3+1),super.GetThisPosition(index*3+2)); | ||
190 | } else { | ||
191 | return PBJ._PBJ.CastVector3d(); | ||
192 | } | ||
193 | } | ||
194 | public Builder AddThisPosition(PBJ.Vector3d value) { | ||
195 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
196 | super.AddThisPosition(_PBJtempArray[0]); | ||
197 | super.AddThisPosition(_PBJtempArray[1]); | ||
198 | super.AddThisPosition(_PBJtempArray[2]); | ||
199 | return this; | ||
200 | } | ||
201 | public Builder SetThisPosition(int index,PBJ.Vector3d value) { | ||
202 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
203 | super.SetThisPosition(index*3+0,_PBJtempArray[0]); | ||
204 | super.SetThisPosition(index*3+1,_PBJtempArray[1]); | ||
205 | super.SetThisPosition(index*3+2,_PBJtempArray[2]); | ||
206 | return this; | ||
207 | } | ||
208 | public Builder ClearOtherPosition() { super.ClearOtherPosition();return this;} | ||
209 | public const int OtherPositionFieldTag=4; | ||
210 | public int OtherPositionCount { get { return super.OtherPositionCount/3;} } | ||
211 | public bool HasOtherPosition(int index) { return true; } | ||
212 | public PBJ.Vector3d GetOtherPosition(int index) { | ||
213 | if (HasOtherPosition(index)) { | ||
214 | return PBJ._PBJ.CastVector3d(super.GetOtherPosition(index*3+0),super.GetOtherPosition(index*3+1),super.GetOtherPosition(index*3+2)); | ||
215 | } else { | ||
216 | return PBJ._PBJ.CastVector3d(); | ||
217 | } | ||
218 | } | ||
219 | public Builder AddOtherPosition(PBJ.Vector3d value) { | ||
220 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
221 | super.AddOtherPosition(_PBJtempArray[0]); | ||
222 | super.AddOtherPosition(_PBJtempArray[1]); | ||
223 | super.AddOtherPosition(_PBJtempArray[2]); | ||
224 | return this; | ||
225 | } | ||
226 | public Builder SetOtherPosition(int index,PBJ.Vector3d value) { | ||
227 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
228 | super.SetOtherPosition(index*3+0,_PBJtempArray[0]); | ||
229 | super.SetOtherPosition(index*3+1,_PBJtempArray[1]); | ||
230 | super.SetOtherPosition(index*3+2,_PBJtempArray[2]); | ||
231 | return this; | ||
232 | } | ||
233 | public Builder ClearThisNormal() { super.ClearThisNormal();return this;} | ||
234 | public const int ThisNormalFieldTag=5; | ||
235 | public int ThisNormalCount { get { return super.ThisNormalCount/2;} } | ||
236 | public bool HasThisNormal(int index) { return true; } | ||
237 | public PBJ.Vector3f GetThisNormal(int index) { | ||
238 | if (HasThisNormal(index)) { | ||
239 | return PBJ._PBJ.CastNormal(super.GetThisNormal(index*2+0),super.GetThisNormal(index*2+1)); | ||
240 | } else { | ||
241 | return PBJ._PBJ.CastNormal(); | ||
242 | } | ||
243 | } | ||
244 | public Builder AddThisNormal(PBJ.Vector3f value) { | ||
245 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
246 | super.AddThisNormal(_PBJtempArray[0]); | ||
247 | super.AddThisNormal(_PBJtempArray[1]); | ||
248 | return this; | ||
249 | } | ||
250 | public Builder SetThisNormal(int index,PBJ.Vector3f value) { | ||
251 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
252 | super.SetThisNormal(index*2+0,_PBJtempArray[0]); | ||
253 | super.SetThisNormal(index*2+1,_PBJtempArray[1]); | ||
254 | return this; | ||
255 | } | ||
256 | public Builder ClearImpulse() { super.ClearImpulse();return this;} | ||
257 | public Builder SetImpulse(int index, float value) { | ||
258 | super.SetImpulse(index,PBJ._PBJ.Construct(value)); | ||
259 | return this; | ||
260 | } | ||
261 | public const int ImpulseFieldTag=6; | ||
262 | public int ImpulseCount { get { return super.ImpulseCount;} } | ||
263 | public bool HasImpulse(int index) {return PBJ._PBJ.ValidateFloat(super.GetImpulse(index));} | ||
264 | public float Impulse(int index) { | ||
265 | return (float)PBJ._PBJ.CastFloat(super.GetImpulse(index)); | ||
266 | } | ||
267 | public Builder AddImpulse(float value) { | ||
268 | super.AddImpulse(PBJ._PBJ.Construct(value)); | ||
269 | return this; | ||
270 | } | ||
271 | public Builder ClearOtherObjectReference() { super.ClearOtherObjectReference();return this;} | ||
272 | public const int OtherObjectReferenceFieldTag=7; | ||
273 | public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } | ||
274 | public PBJ.UUID OtherObjectReference{ get { | ||
275 | if (HasOtherObjectReference) { | ||
276 | return PBJ._PBJ.CastUuid(super.OtherObjectReference); | ||
277 | } else { | ||
278 | return PBJ._PBJ.CastUuid(); | ||
279 | } | ||
280 | } | ||
281 | set { | ||
282 | super.OtherObjectReference=(PBJ._PBJ.Construct(value)); | ||
283 | } | ||
284 | } | ||
285 | } | ||
286 | } | ||
287 | } | ||
288 | namespace Sirikata.Physics.Protocol { | ||
289 | public class CollisionEnd : PBJ.IMessage { | ||
290 | protected _PBJ_Internal.CollisionEnd super; | ||
291 | public _PBJ_Internal.CollisionEnd _PBJSuper{ get { return super;} } | ||
292 | public CollisionEnd() { | ||
293 | super=new _PBJ_Internal.CollisionEnd(); | ||
294 | } | ||
295 | public CollisionEnd(_PBJ_Internal.CollisionEnd reference) { | ||
296 | super=reference; | ||
297 | } | ||
298 | public static CollisionEnd defaultInstance= new CollisionEnd (_PBJ_Internal.CollisionEnd.DefaultInstance); | ||
299 | public static CollisionEnd DefaultInstance{ | ||
300 | get {return defaultInstance;} | ||
301 | } | ||
302 | public static pbd.MessageDescriptor Descriptor { | ||
303 | get { return _PBJ_Internal.CollisionEnd.Descriptor; } } | ||
304 | public static class Types { | ||
305 | } | ||
306 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
307 | return false; | ||
308 | } | ||
309 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
310 | return false; | ||
311 | } | ||
312 | public const int TimestampFieldTag=2; | ||
313 | public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } | ||
314 | public PBJ.Time Timestamp{ get { | ||
315 | if (HasTimestamp) { | ||
316 | return PBJ._PBJ.CastTime(super.Timestamp); | ||
317 | } else { | ||
318 | return PBJ._PBJ.CastTime(); | ||
319 | } | ||
320 | } | ||
321 | } | ||
322 | public const int OtherObjectReferenceFieldTag=6; | ||
323 | public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } | ||
324 | public PBJ.UUID OtherObjectReference{ get { | ||
325 | if (HasOtherObjectReference) { | ||
326 | return PBJ._PBJ.CastUuid(super.OtherObjectReference); | ||
327 | } else { | ||
328 | return PBJ._PBJ.CastUuid(); | ||
329 | } | ||
330 | } | ||
331 | } | ||
332 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
333 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
334 | public static Builder CreateBuilder() { return new Builder(); } | ||
335 | public static Builder CreateBuilder(CollisionEnd prototype) { | ||
336 | return (Builder)new Builder().MergeFrom(prototype); | ||
337 | } | ||
338 | public static CollisionEnd ParseFrom(pb::ByteString data) { | ||
339 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); | ||
340 | } | ||
341 | public static CollisionEnd ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
342 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); | ||
343 | } | ||
344 | public static CollisionEnd ParseFrom(byte[] data) { | ||
345 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); | ||
346 | } | ||
347 | public static CollisionEnd ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
348 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); | ||
349 | } | ||
350 | public static CollisionEnd ParseFrom(global::System.IO.Stream data) { | ||
351 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); | ||
352 | } | ||
353 | public static CollisionEnd ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
354 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); | ||
355 | } | ||
356 | public static CollisionEnd ParseFrom(pb::CodedInputStream data) { | ||
357 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data)); | ||
358 | } | ||
359 | public static CollisionEnd ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
360 | return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er)); | ||
361 | } | ||
362 | protected override bool _HasAllPBJFields{ get { | ||
363 | return true | ||
364 | ; | ||
365 | } } | ||
366 | public bool IsInitialized { get { | ||
367 | return super.IsInitialized&&_HasAllPBJFields; | ||
368 | } } | ||
369 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
370 | protected override bool _HasAllPBJFields{ get { | ||
371 | return true | ||
372 | ; | ||
373 | } } | ||
374 | public bool IsInitialized { get { | ||
375 | return super.IsInitialized&&_HasAllPBJFields; | ||
376 | } } | ||
377 | protected _PBJ_Internal.CollisionEnd.Builder super; | ||
378 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
379 | public _PBJ_Internal.CollisionEnd.Builder _PBJSuper{ get { return super;} } | ||
380 | public Builder() {super = new _PBJ_Internal.CollisionEnd.Builder();} | ||
381 | public Builder(_PBJ_Internal.CollisionEnd.Builder other) { | ||
382 | super=other; | ||
383 | } | ||
384 | public Builder Clone() {return new Builder(super.Clone());} | ||
385 | public Builder MergeFrom(CollisionEnd prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
386 | public Builder Clear() {super.Clear();return this;} | ||
387 | public CollisionEnd BuildPartial() {return new CollisionEnd(super.BuildPartial());} | ||
388 | public CollisionEnd Build() {if (_HasAllPBJFields) return new CollisionEnd(super.Build());return null;} | ||
389 | public pbd::MessageDescriptor DescriptorForType { | ||
390 | get { return CollisionEnd.Descriptor; } } | ||
391 | public Builder ClearTimestamp() { super.ClearTimestamp();return this;} | ||
392 | public const int TimestampFieldTag=2; | ||
393 | public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } | ||
394 | public PBJ.Time Timestamp{ get { | ||
395 | if (HasTimestamp) { | ||
396 | return PBJ._PBJ.CastTime(super.Timestamp); | ||
397 | } else { | ||
398 | return PBJ._PBJ.CastTime(); | ||
399 | } | ||
400 | } | ||
401 | set { | ||
402 | super.Timestamp=(PBJ._PBJ.Construct(value)); | ||
403 | } | ||
404 | } | ||
405 | public Builder ClearOtherObjectReference() { super.ClearOtherObjectReference();return this;} | ||
406 | public const int OtherObjectReferenceFieldTag=6; | ||
407 | public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} } | ||
408 | public PBJ.UUID OtherObjectReference{ get { | ||
409 | if (HasOtherObjectReference) { | ||
410 | return PBJ._PBJ.CastUuid(super.OtherObjectReference); | ||
411 | } else { | ||
412 | return PBJ._PBJ.CastUuid(); | ||
413 | } | ||
414 | } | ||
415 | set { | ||
416 | super.OtherObjectReference=(PBJ._PBJ.Construct(value)); | ||
417 | } | ||
418 | } | ||
419 | } | ||
420 | } | ||
421 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Sirikata.cs b/OpenSim/Client/Sirikata/Protocol/Sirikata.cs deleted file mode 100644 index 9283086..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Sirikata.cs +++ /dev/null | |||
@@ -1,8074 +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 Sirikata { | ||
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_MessageBody__Descriptor; | ||
17 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.MessageBody, global::Sirikata.Protocol._PBJ_Internal.MessageBody.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable; | ||
18 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor; | ||
19 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage, global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable; | ||
20 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor; | ||
21 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.SpaceServices, global::Sirikata.Protocol._PBJ_Internal.SpaceServices.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable; | ||
22 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor; | ||
23 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ObjLoc, global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable; | ||
24 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor; | ||
25 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.LocRequest, global::Sirikata.Protocol._PBJ_Internal.LocRequest.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable; | ||
26 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor; | ||
27 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.NewObj, global::Sirikata.Protocol._PBJ_Internal.NewObj.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable; | ||
28 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor; | ||
29 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.RetObj, global::Sirikata.Protocol._PBJ_Internal.RetObj.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable; | ||
30 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor; | ||
31 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.DelObj, global::Sirikata.Protocol._PBJ_Internal.DelObj.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable; | ||
32 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor; | ||
33 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.NewProxQuery, global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable; | ||
34 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor; | ||
35 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ProxCall, global::Sirikata.Protocol._PBJ_Internal.ProxCall.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable; | ||
36 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor; | ||
37 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.DelProxQuery, global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable; | ||
38 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor; | ||
39 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty, global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable; | ||
40 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor; | ||
41 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.StringProperty, global::Sirikata.Protocol._PBJ_Internal.StringProperty.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable; | ||
42 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor; | ||
43 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.StringMapProperty, global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable; | ||
44 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor; | ||
45 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters, global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable; | ||
46 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor; | ||
47 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty, global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable; | ||
48 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor; | ||
49 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ParentProperty, global::Sirikata.Protocol._PBJ_Internal.ParentProperty.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable; | ||
50 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor; | ||
51 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty, global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable; | ||
52 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor; | ||
53 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable; | ||
54 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor; | ||
55 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.CreateObject, global::Sirikata.Protocol._PBJ_Internal.CreateObject.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable; | ||
56 | #endregion | ||
57 | #region Descriptor | ||
58 | public static pbd::FileDescriptor Descriptor { | ||
59 | get { return descriptor; } | ||
60 | } | ||
61 | private static pbd::FileDescriptor descriptor; | ||
62 | |||
63 | static Sirikata() { | ||
64 | byte[] descriptorData = global::System.Convert.FromBase64String( | ||
65 | "Cg5TaXJpa2F0YS5wcm90bxIfU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRl" + | ||
66 | "cm5hbCI/CgtNZXNzYWdlQm9keRIVCg1tZXNzYWdlX25hbWVzGAkgAygJEhkK" + | ||
67 | "EW1lc3NhZ2VfYXJndW1lbnRzGAogAygMIroDCg9SZWFkT25seU1lc3NhZ2US" + | ||
68 | "FQoNc291cmNlX29iamVjdBgBIAEoDBITCgtzb3VyY2VfcG9ydBgDIAEoDRIV" + | ||
69 | "Cgxzb3VyY2Vfc3BhY2UYgAwgASgMEhoKEmRlc3RpbmF0aW9uX29iamVjdBgC" + | ||
70 | "IAEoDBIYChBkZXN0aW5hdGlvbl9wb3J0GAQgASgNEhoKEWRlc3RpbmF0aW9u" + | ||
71 | "X3NwYWNlGIEMIAEoDBIKCgJpZBgHIAEoAxIQCghyZXBseV9pZBgIIAEoAxJV" + | ||
72 | "Cg1yZXR1cm5fc3RhdHVzGIAOIAEoDjI9LlNpcmlrYXRhLlByb3RvY29sLl9Q" + | ||
73 | "QkpfSW50ZXJuYWwuUmVhZE9ubHlNZXNzYWdlLlJldHVyblN0YXR1cxIVCg1t" + | ||
74 | "ZXNzYWdlX25hbWVzGAkgAygJEhkKEW1lc3NhZ2VfYXJndW1lbnRzGAogAygM" + | ||
75 | "ImsKDFJldHVyblN0YXR1cxILCgdTVUNDRVNTEAASEwoPTkVUV09SS19GQUlM" + | ||
76 | "VVJFEAESEwoPVElNRU9VVF9GQUlMVVJFEAMSEgoOUFJPVE9DT0xfRVJST1IQ" + | ||
77 | "BBIQCgxQT1JUX0ZBSUxVUkUQBSLOAQoNU3BhY2VTZXJ2aWNlcxIZChFyZWdp" + | ||
78 | "c3RyYXRpb25fcG9ydBghIAEoDRIQCghsb2NfcG9ydBgiIAEoDRIRCglnZW9t" + | ||
79 | "X3BvcnQYIyABKA0SEQoJb3NlZ19wb3J0GCQgASgNEhEKCWNzZWdfcG9ydBgl" + | ||
80 | "IAEoDRITCgtyb3V0ZXJfcG9ydBgmIAEoDRIdChVwcmVfY29ubmVjdGlvbl9i" + | ||
81 | "dWZmZXIYQCABKAQSIwobbWF4X3ByZV9jb25uZWN0aW9uX21lc3NhZ2VzGEEg" + | ||
82 | "ASgEIsQBCgZPYmpMb2MSEQoJdGltZXN0YW1wGAIgASgGEhQKCHBvc2l0aW9u" + | ||
83 | "GAMgAygBQgIQARIXCgtvcmllbnRhdGlvbhgEIAMoAkICEAESFAoIdmVsb2Np" + | ||
84 | "dHkYBSADKAJCAhABEhsKD3JvdGF0aW9uYWxfYXhpcxgHIAMoAkICEAESFQoN" + | ||
85 | "YW5ndWxhcl9zcGVlZBgIIAEoAhIUCgx1cGRhdGVfZmxhZ3MYBiABKA0iGAoL" + | ||
86 | "VXBkYXRlRmxhZ3MSCQoFRk9SQ0UQASKFAQoKTG9jUmVxdWVzdBIYChByZXF1" + | ||
87 | "ZXN0ZWRfZmllbGRzGAIgASgNIl0KBkZpZWxkcxIMCghQT1NJVElPThABEg8K" + | ||
88 | "C09SSUVOVEFUSU9OEAISDAoIVkVMT0NJVFkQBBITCg9ST1RBVElPTkFMX0FY" + | ||
89 | "SVMQCBIRCg1BTkdVTEFSX1NQRUVEEBAiigEKBk5ld09iahIcChRvYmplY3Rf" + | ||
90 | "dXVpZF9ldmlkZW5jZRgCIAEoDBJFChRyZXF1ZXN0ZWRfb2JqZWN0X2xvYxgD" + | ||
91 | "IAEoCzInLlNpcmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuT2JqTG9j" + | ||
92 | "EhsKD2JvdW5kaW5nX3NwaGVyZRgEIAMoAkICEAEiegoGUmV0T2JqEhgKEG9i" + | ||
93 | "amVjdF9yZWZlcmVuY2UYAiABKAwSOQoIbG9jYXRpb24YAyABKAsyJy5TaXJp" + | ||
94 | "a2F0YS5Qcm90b2NvbC5fUEJKX0ludGVybmFsLk9iakxvYxIbCg9ib3VuZGlu" + | ||
95 | "Z19zcGhlcmUYBCADKAJCAhABIiIKBkRlbE9iahIYChBvYmplY3RfcmVmZXJl" + | ||
96 | "bmNlGAIgASgMIpoBCgxOZXdQcm94UXVlcnkSEAoIcXVlcnlfaWQYAiABKA0S" + | ||
97 | "EQoJc3RhdGVsZXNzGAMgASgIEhsKD3JlbGF0aXZlX2NlbnRlchgEIAMoAkIC" + | ||
98 | "EAESGwoPYWJzb2x1dGVfY2VudGVyGAUgAygBQgIQARISCgptYXhfcmFkaXVz" + | ||
99 | "GAYgASgCEhcKD21pbl9zb2xpZF9hbmdsZRgHIAEoAiLhAQoIUHJveENhbGwS" + | ||
100 | "EAoIcXVlcnlfaWQYAiACKA0SGAoQcHJveGltYXRlX29iamVjdBgDIAIoDBJR" + | ||
101 | "Cg9wcm94aW1pdHlfZXZlbnQYBCACKA4yOC5TaXJpa2F0YS5Qcm90b2NvbC5f" + | ||
102 | "UEJKX0ludGVybmFsLlByb3hDYWxsLlByb3hpbWl0eUV2ZW50IlYKDlByb3hp" + | ||
103 | "bWl0eUV2ZW50EhQKEEVYSVRFRF9QUk9YSU1JVFkQABIVChFFTlRFUkVEX1BS" + | ||
104 | "T1hJTUlUWRABEhcKE1NUQVRFTEVTU19QUk9YSU1JVFkQAiIgCgxEZWxQcm94" + | ||
105 | "UXVlcnkSEAoIcXVlcnlfaWQYAiABKA0iJQoQVmVjdG9yM2ZQcm9wZXJ0eRIR" + | ||
106 | "CgV2YWx1ZRgKIAMoAkICEAEiHwoOU3RyaW5nUHJvcGVydHkSDQoFdmFsdWUY" + | ||
107 | "CiABKAkiMQoRU3RyaW5nTWFwUHJvcGVydHkSDAoEa2V5cxgCIAMoCRIOCgZ2" + | ||
108 | "YWx1ZXMYAyADKAkiyQIKElBoeXNpY2FsUGFyYW1ldGVycxJGCgRtb2RlGAIg" + | ||
109 | "ASgOMjguU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5QaHlzaWNh" + | ||
110 | "bFBhcmFtZXRlcnMuTW9kZRIPCgdkZW5zaXR5GAMgASgCEhAKCGZyaWN0aW9u" + | ||
111 | "GAQgASgCEg4KBmJvdW5jZRgFIAEoAhIQCgRodWxsGAYgAygCQgIQARITCgtj" + | ||
112 | "b2xsaWRlX21zZxgQIAEoDRIUCgxjb2xsaWRlX21hc2sYESABKA0SDwoHZ3Jh" + | ||
113 | "dml0eRgSIAEoAiJqCgRNb2RlEg8KC05PTlBIWVNJQ0FMEAASCgoGU1RBVElD" + | ||
114 | "EAESDgoKRFlOQU1JQ0JPWBACEhEKDURZTkFNSUNTUEhFUkUQAxITCg9EWU5B" + | ||
115 | "TUlDQ1lMSU5ERVIQBBINCglDSEFSQUNURVIQBSLaAwoRTGlnaHRJbmZvUHJv" + | ||
116 | "cGVydHkSGQoNZGlmZnVzZV9jb2xvchgDIAMoAkICEAESGgoOc3BlY3VsYXJf" + | ||
117 | "Y29sb3IYBCADKAJCAhABEg0KBXBvd2VyGAUgASgCEhkKDWFtYmllbnRfY29s" + | ||
118 | "b3IYBiADKAJCAhABEhgKDHNoYWRvd19jb2xvchgHIAMoAkICEAESEwoLbGln" + | ||
119 | "aHRfcmFuZ2UYCCABKAESGAoQY29uc3RhbnRfZmFsbG9mZhgJIAEoAhIWCg5s" + | ||
120 | "aW5lYXJfZmFsbG9mZhgKIAEoAhIZChFxdWFkcmF0aWNfZmFsbG9mZhgLIAEo" + | ||
121 | "AhIaChJjb25lX2lubmVyX3JhZGlhbnMYDCABKAISGgoSY29uZV9vdXRlcl9y" + | ||
122 | "YWRpYW5zGA0gASgCEhQKDGNvbmVfZmFsbG9mZhgOIAEoAhJLCgR0eXBlGA8g" + | ||
123 | "ASgOMj0uU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5MaWdodElu" + | ||
124 | "Zm9Qcm9wZXJ0eS5MaWdodFR5cGVzEhQKDGNhc3RzX3NoYWRvdxgQIAEoCCI3" + | ||
125 | "CgpMaWdodFR5cGVzEgkKBVBPSU5UEAASDQoJU1BPVExJR0hUEAESDwoLRElS" + | ||
126 | "RUNUSU9OQUwQAiIfCg5QYXJlbnRQcm9wZXJ0eRINCgV2YWx1ZRgKIAEoDCIh" + | ||
127 | "ChBVVUlETGlzdFByb3BlcnR5Eg0KBXZhbHVlGAogAygMIqQBCg5Db25uZWN0" + | ||
128 | "VG9TcGFjZRIQCghzcGFjZV9pZBgBIAEoDBIcChRvYmplY3RfdXVpZF9ldmlk" + | ||
129 | "ZW5jZRgCIAEoDBJFChRyZXF1ZXN0ZWRfb2JqZWN0X2xvYxgDIAEoCzInLlNp" + | ||
130 | "cmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuT2JqTG9jEhsKD2JvdW5k" + | ||
131 | "aW5nX3NwaGVyZRgEIAMoAkICEAEivgIKDENyZWF0ZU9iamVjdBITCgtvYmpl" + | ||
132 | "Y3RfdXVpZBgBIAEoDBJJChBzcGFjZV9wcm9wZXJ0aWVzGAIgAygLMi8uU2ly" + | ||
133 | "aWthdGEuUHJvdG9jb2wuX1BCSl9JbnRlcm5hbC5Db25uZWN0VG9TcGFjZRIM" + | ||
134 | "CgRtZXNoGAMgASgJEhEKBXNjYWxlGAQgAygCQgIQARIOCgZ3ZWJ1cmwYBSAB" + | ||
135 | "KAkSRgoKbGlnaHRfaW5mbxgGIAEoCzIyLlNpcmlrYXRhLlByb3RvY29sLl9Q" + | ||
136 | "QkpfSW50ZXJuYWwuTGlnaHRJbmZvUHJvcGVydHkSDgoGY2FtZXJhGAcgASgI" + | ||
137 | "EkUKCHBoeXNpY2FsGAggASgLMjMuU2lyaWthdGEuUHJvdG9jb2wuX1BCSl9J" + | ||
138 | "bnRlcm5hbC5QaHlzaWNhbFBhcmFtZXRlcnM="); | ||
139 | pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | ||
140 | descriptor = root; | ||
141 | internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor = Descriptor.MessageTypes[0]; | ||
142 | internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable = | ||
143 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.MessageBody, global::Sirikata.Protocol._PBJ_Internal.MessageBody.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor, | ||
144 | new string[] { "MessageNames", "MessageArguments", }); | ||
145 | internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor = Descriptor.MessageTypes[1]; | ||
146 | internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable = | ||
147 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage, global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor, | ||
148 | new string[] { "SourceObject", "SourcePort", "SourceSpace", "DestinationObject", "DestinationPort", "DestinationSpace", "Id", "ReplyId", "ReturnStatus", "MessageNames", "MessageArguments", }); | ||
149 | internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor = Descriptor.MessageTypes[2]; | ||
150 | internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable = | ||
151 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.SpaceServices, global::Sirikata.Protocol._PBJ_Internal.SpaceServices.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor, | ||
152 | new string[] { "RegistrationPort", "LocPort", "GeomPort", "OsegPort", "CsegPort", "RouterPort", "PreConnectionBuffer", "MaxPreConnectionMessages", }); | ||
153 | internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor = Descriptor.MessageTypes[3]; | ||
154 | internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable = | ||
155 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ObjLoc, global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor, | ||
156 | new string[] { "Timestamp", "Position", "Orientation", "Velocity", "RotationalAxis", "AngularSpeed", "UpdateFlags", }); | ||
157 | internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor = Descriptor.MessageTypes[4]; | ||
158 | internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable = | ||
159 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.LocRequest, global::Sirikata.Protocol._PBJ_Internal.LocRequest.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor, | ||
160 | new string[] { "RequestedFields", }); | ||
161 | internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor = Descriptor.MessageTypes[5]; | ||
162 | internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable = | ||
163 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.NewObj, global::Sirikata.Protocol._PBJ_Internal.NewObj.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor, | ||
164 | new string[] { "ObjectUuidEvidence", "RequestedObjectLoc", "BoundingSphere", }); | ||
165 | internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor = Descriptor.MessageTypes[6]; | ||
166 | internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable = | ||
167 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.RetObj, global::Sirikata.Protocol._PBJ_Internal.RetObj.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor, | ||
168 | new string[] { "ObjectReference", "Location", "BoundingSphere", }); | ||
169 | internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor = Descriptor.MessageTypes[7]; | ||
170 | internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable = | ||
171 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.DelObj, global::Sirikata.Protocol._PBJ_Internal.DelObj.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor, | ||
172 | new string[] { "ObjectReference", }); | ||
173 | internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor = Descriptor.MessageTypes[8]; | ||
174 | internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable = | ||
175 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.NewProxQuery, global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor, | ||
176 | new string[] { "QueryId", "Stateless", "RelativeCenter", "AbsoluteCenter", "MaxRadius", "MinSolidAngle", }); | ||
177 | internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor = Descriptor.MessageTypes[9]; | ||
178 | internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable = | ||
179 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ProxCall, global::Sirikata.Protocol._PBJ_Internal.ProxCall.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor, | ||
180 | new string[] { "QueryId", "ProximateObject", "ProximityEvent", }); | ||
181 | internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor = Descriptor.MessageTypes[10]; | ||
182 | internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable = | ||
183 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.DelProxQuery, global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor, | ||
184 | new string[] { "QueryId", }); | ||
185 | internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor = Descriptor.MessageTypes[11]; | ||
186 | internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable = | ||
187 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty, global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor, | ||
188 | new string[] { "Value", }); | ||
189 | internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor = Descriptor.MessageTypes[12]; | ||
190 | internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable = | ||
191 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.StringProperty, global::Sirikata.Protocol._PBJ_Internal.StringProperty.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor, | ||
192 | new string[] { "Value", }); | ||
193 | internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor = Descriptor.MessageTypes[13]; | ||
194 | internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable = | ||
195 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.StringMapProperty, global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor, | ||
196 | new string[] { "Keys", "Values", }); | ||
197 | internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor = Descriptor.MessageTypes[14]; | ||
198 | internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable = | ||
199 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters, global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor, | ||
200 | new string[] { "Mode", "Density", "Friction", "Bounce", "Hull", "CollideMsg", "CollideMask", "Gravity", }); | ||
201 | internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor = Descriptor.MessageTypes[15]; | ||
202 | internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable = | ||
203 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty, global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor, | ||
204 | new string[] { "DiffuseColor", "SpecularColor", "Power", "AmbientColor", "ShadowColor", "LightRange", "ConstantFalloff", "LinearFalloff", "QuadraticFalloff", "ConeInnerRadians", "ConeOuterRadians", "ConeFalloff", "Type", "CastsShadow", }); | ||
205 | internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor = Descriptor.MessageTypes[16]; | ||
206 | internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable = | ||
207 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ParentProperty, global::Sirikata.Protocol._PBJ_Internal.ParentProperty.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor, | ||
208 | new string[] { "Value", }); | ||
209 | internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor = Descriptor.MessageTypes[17]; | ||
210 | internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable = | ||
211 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty, global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor, | ||
212 | new string[] { "Value", }); | ||
213 | internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor = Descriptor.MessageTypes[18]; | ||
214 | internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable = | ||
215 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor, | ||
216 | new string[] { "SpaceId", "ObjectUuidEvidence", "RequestedObjectLoc", "BoundingSphere", }); | ||
217 | internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor = Descriptor.MessageTypes[19]; | ||
218 | internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable = | ||
219 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.CreateObject, global::Sirikata.Protocol._PBJ_Internal.CreateObject.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor, | ||
220 | new string[] { "ObjectUuid", "SpaceProperties", "Mesh", "Scale", "Weburl", "LightInfo", "Camera", "Physical", }); | ||
221 | return null; | ||
222 | }; | ||
223 | pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | ||
224 | new pbd::FileDescriptor[] { | ||
225 | }, assigner); | ||
226 | } | ||
227 | #endregion | ||
228 | |||
229 | } | ||
230 | #region Messages | ||
231 | public sealed partial class MessageBody : pb::GeneratedMessage<MessageBody, MessageBody.Builder> { | ||
232 | private static readonly MessageBody defaultInstance = new Builder().BuildPartial(); | ||
233 | public static MessageBody DefaultInstance { | ||
234 | get { return defaultInstance; } | ||
235 | } | ||
236 | |||
237 | public override MessageBody DefaultInstanceForType { | ||
238 | get { return defaultInstance; } | ||
239 | } | ||
240 | |||
241 | protected override MessageBody ThisMessage { | ||
242 | get { return this; } | ||
243 | } | ||
244 | |||
245 | public static pbd::MessageDescriptor Descriptor { | ||
246 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__Descriptor; } | ||
247 | } | ||
248 | |||
249 | protected override pb::FieldAccess.FieldAccessorTable<MessageBody, MessageBody.Builder> InternalFieldAccessors { | ||
250 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_MessageBody__FieldAccessorTable; } | ||
251 | } | ||
252 | |||
253 | public const int MessageNamesFieldNumber = 9; | ||
254 | private pbc::PopsicleList<string> messageNames_ = new pbc::PopsicleList<string>(); | ||
255 | public scg::IList<string> MessageNamesList { | ||
256 | get { return pbc::Lists.AsReadOnly(messageNames_); } | ||
257 | } | ||
258 | public int MessageNamesCount { | ||
259 | get { return messageNames_.Count; } | ||
260 | } | ||
261 | public string GetMessageNames(int index) { | ||
262 | return messageNames_[index]; | ||
263 | } | ||
264 | |||
265 | public const int MessageArgumentsFieldNumber = 10; | ||
266 | private pbc::PopsicleList<pb::ByteString> messageArguments_ = new pbc::PopsicleList<pb::ByteString>(); | ||
267 | public scg::IList<pb::ByteString> MessageArgumentsList { | ||
268 | get { return pbc::Lists.AsReadOnly(messageArguments_); } | ||
269 | } | ||
270 | public int MessageArgumentsCount { | ||
271 | get { return messageArguments_.Count; } | ||
272 | } | ||
273 | public pb::ByteString GetMessageArguments(int index) { | ||
274 | return messageArguments_[index]; | ||
275 | } | ||
276 | |||
277 | public override bool IsInitialized { | ||
278 | get { | ||
279 | return true; | ||
280 | } | ||
281 | } | ||
282 | |||
283 | public override void WriteTo(pb::CodedOutputStream output) { | ||
284 | if (messageNames_.Count > 0) { | ||
285 | foreach (string element in messageNames_) { | ||
286 | output.WriteString(9, element); | ||
287 | } | ||
288 | } | ||
289 | if (messageArguments_.Count > 0) { | ||
290 | foreach (pb::ByteString element in messageArguments_) { | ||
291 | output.WriteBytes(10, element); | ||
292 | } | ||
293 | } | ||
294 | UnknownFields.WriteTo(output); | ||
295 | } | ||
296 | |||
297 | private int memoizedSerializedSize = -1; | ||
298 | public override int SerializedSize { | ||
299 | get { | ||
300 | int size = memoizedSerializedSize; | ||
301 | if (size != -1) return size; | ||
302 | |||
303 | size = 0; | ||
304 | { | ||
305 | int dataSize = 0; | ||
306 | foreach (string element in MessageNamesList) { | ||
307 | dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | ||
308 | } | ||
309 | size += dataSize; | ||
310 | size += 1 * messageNames_.Count; | ||
311 | } | ||
312 | { | ||
313 | int dataSize = 0; | ||
314 | foreach (pb::ByteString element in MessageArgumentsList) { | ||
315 | dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); | ||
316 | } | ||
317 | size += dataSize; | ||
318 | size += 1 * messageArguments_.Count; | ||
319 | } | ||
320 | size += UnknownFields.SerializedSize; | ||
321 | memoizedSerializedSize = size; | ||
322 | return size; | ||
323 | } | ||
324 | } | ||
325 | |||
326 | public static MessageBody ParseFrom(pb::ByteString data) { | ||
327 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
328 | } | ||
329 | public static MessageBody ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
330 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
331 | } | ||
332 | public static MessageBody ParseFrom(byte[] data) { | ||
333 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
334 | } | ||
335 | public static MessageBody ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
336 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
337 | } | ||
338 | public static MessageBody ParseFrom(global::System.IO.Stream input) { | ||
339 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
340 | } | ||
341 | public static MessageBody ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
342 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
343 | } | ||
344 | public static MessageBody ParseDelimitedFrom(global::System.IO.Stream input) { | ||
345 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
346 | } | ||
347 | public static MessageBody ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
348 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
349 | } | ||
350 | public static MessageBody ParseFrom(pb::CodedInputStream input) { | ||
351 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
352 | } | ||
353 | public static MessageBody ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
354 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
355 | } | ||
356 | public static Builder CreateBuilder() { return new Builder(); } | ||
357 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
358 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
359 | public static Builder CreateBuilder(MessageBody prototype) { | ||
360 | return (Builder) new Builder().MergeFrom(prototype); | ||
361 | } | ||
362 | |||
363 | public sealed partial class Builder : pb::GeneratedBuilder<MessageBody, Builder> { | ||
364 | protected override Builder ThisBuilder { | ||
365 | get { return this; } | ||
366 | } | ||
367 | public Builder() {} | ||
368 | |||
369 | MessageBody result = new MessageBody(); | ||
370 | |||
371 | protected override MessageBody MessageBeingBuilt { | ||
372 | get { return result; } | ||
373 | } | ||
374 | |||
375 | public override Builder Clear() { | ||
376 | result = new MessageBody(); | ||
377 | return this; | ||
378 | } | ||
379 | |||
380 | public override Builder Clone() { | ||
381 | return new Builder().MergeFrom(result); | ||
382 | } | ||
383 | |||
384 | public override pbd::MessageDescriptor DescriptorForType { | ||
385 | get { return global::Sirikata.Protocol._PBJ_Internal.MessageBody.Descriptor; } | ||
386 | } | ||
387 | |||
388 | public override MessageBody DefaultInstanceForType { | ||
389 | get { return global::Sirikata.Protocol._PBJ_Internal.MessageBody.DefaultInstance; } | ||
390 | } | ||
391 | |||
392 | public override MessageBody BuildPartial() { | ||
393 | if (result == null) { | ||
394 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
395 | } | ||
396 | result.messageNames_.MakeReadOnly(); | ||
397 | result.messageArguments_.MakeReadOnly(); | ||
398 | MessageBody returnMe = result; | ||
399 | result = null; | ||
400 | return returnMe; | ||
401 | } | ||
402 | |||
403 | public override Builder MergeFrom(pb::IMessage other) { | ||
404 | if (other is MessageBody) { | ||
405 | return MergeFrom((MessageBody) other); | ||
406 | } else { | ||
407 | base.MergeFrom(other); | ||
408 | return this; | ||
409 | } | ||
410 | } | ||
411 | |||
412 | public override Builder MergeFrom(MessageBody other) { | ||
413 | if (other == global::Sirikata.Protocol._PBJ_Internal.MessageBody.DefaultInstance) return this; | ||
414 | if (other.messageNames_.Count != 0) { | ||
415 | base.AddRange(other.messageNames_, result.messageNames_); | ||
416 | } | ||
417 | if (other.messageArguments_.Count != 0) { | ||
418 | base.AddRange(other.messageArguments_, result.messageArguments_); | ||
419 | } | ||
420 | this.MergeUnknownFields(other.UnknownFields); | ||
421 | return this; | ||
422 | } | ||
423 | |||
424 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
425 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
426 | } | ||
427 | |||
428 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
429 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
430 | while (true) { | ||
431 | uint tag = input.ReadTag(); | ||
432 | switch (tag) { | ||
433 | case 0: { | ||
434 | if (unknownFields != null) { | ||
435 | this.UnknownFields = unknownFields.Build(); | ||
436 | } | ||
437 | return this; | ||
438 | } | ||
439 | default: { | ||
440 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
441 | if (unknownFields != null) { | ||
442 | this.UnknownFields = unknownFields.Build(); | ||
443 | } | ||
444 | return this; | ||
445 | } | ||
446 | if (unknownFields == null) { | ||
447 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
448 | } | ||
449 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
450 | break; | ||
451 | } | ||
452 | case 74: { | ||
453 | AddMessageNames(input.ReadString()); | ||
454 | break; | ||
455 | } | ||
456 | case 82: { | ||
457 | AddMessageArguments(input.ReadBytes()); | ||
458 | break; | ||
459 | } | ||
460 | } | ||
461 | } | ||
462 | } | ||
463 | |||
464 | |||
465 | public pbc::IPopsicleList<string> MessageNamesList { | ||
466 | get { return result.messageNames_; } | ||
467 | } | ||
468 | public int MessageNamesCount { | ||
469 | get { return result.MessageNamesCount; } | ||
470 | } | ||
471 | public string GetMessageNames(int index) { | ||
472 | return result.GetMessageNames(index); | ||
473 | } | ||
474 | public Builder SetMessageNames(int index, string value) { | ||
475 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
476 | result.messageNames_[index] = value; | ||
477 | return this; | ||
478 | } | ||
479 | public Builder AddMessageNames(string value) { | ||
480 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
481 | result.messageNames_.Add(value); | ||
482 | return this; | ||
483 | } | ||
484 | public Builder AddRangeMessageNames(scg::IEnumerable<string> values) { | ||
485 | base.AddRange(values, result.messageNames_); | ||
486 | return this; | ||
487 | } | ||
488 | public Builder ClearMessageNames() { | ||
489 | result.messageNames_.Clear(); | ||
490 | return this; | ||
491 | } | ||
492 | |||
493 | public pbc::IPopsicleList<pb::ByteString> MessageArgumentsList { | ||
494 | get { return result.messageArguments_; } | ||
495 | } | ||
496 | public int MessageArgumentsCount { | ||
497 | get { return result.MessageArgumentsCount; } | ||
498 | } | ||
499 | public pb::ByteString GetMessageArguments(int index) { | ||
500 | return result.GetMessageArguments(index); | ||
501 | } | ||
502 | public Builder SetMessageArguments(int index, pb::ByteString value) { | ||
503 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
504 | result.messageArguments_[index] = value; | ||
505 | return this; | ||
506 | } | ||
507 | public Builder AddMessageArguments(pb::ByteString value) { | ||
508 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
509 | result.messageArguments_.Add(value); | ||
510 | return this; | ||
511 | } | ||
512 | public Builder AddRangeMessageArguments(scg::IEnumerable<pb::ByteString> values) { | ||
513 | base.AddRange(values, result.messageArguments_); | ||
514 | return this; | ||
515 | } | ||
516 | public Builder ClearMessageArguments() { | ||
517 | result.messageArguments_.Clear(); | ||
518 | return this; | ||
519 | } | ||
520 | } | ||
521 | static MessageBody() { | ||
522 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
523 | } | ||
524 | } | ||
525 | |||
526 | public sealed partial class ReadOnlyMessage : pb::GeneratedMessage<ReadOnlyMessage, ReadOnlyMessage.Builder> { | ||
527 | private static readonly ReadOnlyMessage defaultInstance = new Builder().BuildPartial(); | ||
528 | public static ReadOnlyMessage DefaultInstance { | ||
529 | get { return defaultInstance; } | ||
530 | } | ||
531 | |||
532 | public override ReadOnlyMessage DefaultInstanceForType { | ||
533 | get { return defaultInstance; } | ||
534 | } | ||
535 | |||
536 | protected override ReadOnlyMessage ThisMessage { | ||
537 | get { return this; } | ||
538 | } | ||
539 | |||
540 | public static pbd::MessageDescriptor Descriptor { | ||
541 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__Descriptor; } | ||
542 | } | ||
543 | |||
544 | protected override pb::FieldAccess.FieldAccessorTable<ReadOnlyMessage, ReadOnlyMessage.Builder> InternalFieldAccessors { | ||
545 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ReadOnlyMessage__FieldAccessorTable; } | ||
546 | } | ||
547 | |||
548 | #region Nested types | ||
549 | public static class Types { | ||
550 | public enum ReturnStatus { | ||
551 | SUCCESS = 0, | ||
552 | NETWORK_FAILURE = 1, | ||
553 | TIMEOUT_FAILURE = 3, | ||
554 | PROTOCOL_ERROR = 4, | ||
555 | PORT_FAILURE = 5, | ||
556 | } | ||
557 | |||
558 | } | ||
559 | #endregion | ||
560 | |||
561 | public const int SourceObjectFieldNumber = 1; | ||
562 | private bool hasSourceObject; | ||
563 | private pb::ByteString sourceObject_ = pb::ByteString.Empty; | ||
564 | public bool HasSourceObject { | ||
565 | get { return hasSourceObject; } | ||
566 | } | ||
567 | public pb::ByteString SourceObject { | ||
568 | get { return sourceObject_; } | ||
569 | } | ||
570 | |||
571 | public const int SourcePortFieldNumber = 3; | ||
572 | private bool hasSourcePort; | ||
573 | private uint sourcePort_ = 0; | ||
574 | public bool HasSourcePort { | ||
575 | get { return hasSourcePort; } | ||
576 | } | ||
577 | [global::System.CLSCompliant(false)] | ||
578 | public uint SourcePort { | ||
579 | get { return sourcePort_; } | ||
580 | } | ||
581 | |||
582 | public const int SourceSpaceFieldNumber = 1536; | ||
583 | private bool hasSourceSpace; | ||
584 | private pb::ByteString sourceSpace_ = pb::ByteString.Empty; | ||
585 | public bool HasSourceSpace { | ||
586 | get { return hasSourceSpace; } | ||
587 | } | ||
588 | public pb::ByteString SourceSpace { | ||
589 | get { return sourceSpace_; } | ||
590 | } | ||
591 | |||
592 | public const int DestinationObjectFieldNumber = 2; | ||
593 | private bool hasDestinationObject; | ||
594 | private pb::ByteString destinationObject_ = pb::ByteString.Empty; | ||
595 | public bool HasDestinationObject { | ||
596 | get { return hasDestinationObject; } | ||
597 | } | ||
598 | public pb::ByteString DestinationObject { | ||
599 | get { return destinationObject_; } | ||
600 | } | ||
601 | |||
602 | public const int DestinationPortFieldNumber = 4; | ||
603 | private bool hasDestinationPort; | ||
604 | private uint destinationPort_ = 0; | ||
605 | public bool HasDestinationPort { | ||
606 | get { return hasDestinationPort; } | ||
607 | } | ||
608 | [global::System.CLSCompliant(false)] | ||
609 | public uint DestinationPort { | ||
610 | get { return destinationPort_; } | ||
611 | } | ||
612 | |||
613 | public const int DestinationSpaceFieldNumber = 1537; | ||
614 | private bool hasDestinationSpace; | ||
615 | private pb::ByteString destinationSpace_ = pb::ByteString.Empty; | ||
616 | public bool HasDestinationSpace { | ||
617 | get { return hasDestinationSpace; } | ||
618 | } | ||
619 | public pb::ByteString DestinationSpace { | ||
620 | get { return destinationSpace_; } | ||
621 | } | ||
622 | |||
623 | public const int IdFieldNumber = 7; | ||
624 | private bool hasId; | ||
625 | private long id_ = 0L; | ||
626 | public bool HasId { | ||
627 | get { return hasId; } | ||
628 | } | ||
629 | public long Id { | ||
630 | get { return id_; } | ||
631 | } | ||
632 | |||
633 | public const int ReplyIdFieldNumber = 8; | ||
634 | private bool hasReplyId; | ||
635 | private long replyId_ = 0L; | ||
636 | public bool HasReplyId { | ||
637 | get { return hasReplyId; } | ||
638 | } | ||
639 | public long ReplyId { | ||
640 | get { return replyId_; } | ||
641 | } | ||
642 | |||
643 | public const int ReturnStatusFieldNumber = 1792; | ||
644 | private bool hasReturnStatus; | ||
645 | private global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS; | ||
646 | public bool HasReturnStatus { | ||
647 | get { return hasReturnStatus; } | ||
648 | } | ||
649 | public global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus ReturnStatus { | ||
650 | get { return returnStatus_; } | ||
651 | } | ||
652 | |||
653 | public const int MessageNamesFieldNumber = 9; | ||
654 | private pbc::PopsicleList<string> messageNames_ = new pbc::PopsicleList<string>(); | ||
655 | public scg::IList<string> MessageNamesList { | ||
656 | get { return pbc::Lists.AsReadOnly(messageNames_); } | ||
657 | } | ||
658 | public int MessageNamesCount { | ||
659 | get { return messageNames_.Count; } | ||
660 | } | ||
661 | public string GetMessageNames(int index) { | ||
662 | return messageNames_[index]; | ||
663 | } | ||
664 | |||
665 | public const int MessageArgumentsFieldNumber = 10; | ||
666 | private pbc::PopsicleList<pb::ByteString> messageArguments_ = new pbc::PopsicleList<pb::ByteString>(); | ||
667 | public scg::IList<pb::ByteString> MessageArgumentsList { | ||
668 | get { return pbc::Lists.AsReadOnly(messageArguments_); } | ||
669 | } | ||
670 | public int MessageArgumentsCount { | ||
671 | get { return messageArguments_.Count; } | ||
672 | } | ||
673 | public pb::ByteString GetMessageArguments(int index) { | ||
674 | return messageArguments_[index]; | ||
675 | } | ||
676 | |||
677 | public override bool IsInitialized { | ||
678 | get { | ||
679 | return true; | ||
680 | } | ||
681 | } | ||
682 | |||
683 | public override void WriteTo(pb::CodedOutputStream output) { | ||
684 | if (HasSourceObject) { | ||
685 | output.WriteBytes(1, SourceObject); | ||
686 | } | ||
687 | if (HasDestinationObject) { | ||
688 | output.WriteBytes(2, DestinationObject); | ||
689 | } | ||
690 | if (HasSourcePort) { | ||
691 | output.WriteUInt32(3, SourcePort); | ||
692 | } | ||
693 | if (HasDestinationPort) { | ||
694 | output.WriteUInt32(4, DestinationPort); | ||
695 | } | ||
696 | if (HasId) { | ||
697 | output.WriteInt64(7, Id); | ||
698 | } | ||
699 | if (HasReplyId) { | ||
700 | output.WriteInt64(8, ReplyId); | ||
701 | } | ||
702 | if (messageNames_.Count > 0) { | ||
703 | foreach (string element in messageNames_) { | ||
704 | output.WriteString(9, element); | ||
705 | } | ||
706 | } | ||
707 | if (messageArguments_.Count > 0) { | ||
708 | foreach (pb::ByteString element in messageArguments_) { | ||
709 | output.WriteBytes(10, element); | ||
710 | } | ||
711 | } | ||
712 | if (HasSourceSpace) { | ||
713 | output.WriteBytes(1536, SourceSpace); | ||
714 | } | ||
715 | if (HasDestinationSpace) { | ||
716 | output.WriteBytes(1537, DestinationSpace); | ||
717 | } | ||
718 | if (HasReturnStatus) { | ||
719 | output.WriteEnum(1792, (int) ReturnStatus); | ||
720 | } | ||
721 | UnknownFields.WriteTo(output); | ||
722 | } | ||
723 | |||
724 | private int memoizedSerializedSize = -1; | ||
725 | public override int SerializedSize { | ||
726 | get { | ||
727 | int size = memoizedSerializedSize; | ||
728 | if (size != -1) return size; | ||
729 | |||
730 | size = 0; | ||
731 | if (HasSourceObject) { | ||
732 | size += pb::CodedOutputStream.ComputeBytesSize(1, SourceObject); | ||
733 | } | ||
734 | if (HasSourcePort) { | ||
735 | size += pb::CodedOutputStream.ComputeUInt32Size(3, SourcePort); | ||
736 | } | ||
737 | if (HasSourceSpace) { | ||
738 | size += pb::CodedOutputStream.ComputeBytesSize(1536, SourceSpace); | ||
739 | } | ||
740 | if (HasDestinationObject) { | ||
741 | size += pb::CodedOutputStream.ComputeBytesSize(2, DestinationObject); | ||
742 | } | ||
743 | if (HasDestinationPort) { | ||
744 | size += pb::CodedOutputStream.ComputeUInt32Size(4, DestinationPort); | ||
745 | } | ||
746 | if (HasDestinationSpace) { | ||
747 | size += pb::CodedOutputStream.ComputeBytesSize(1537, DestinationSpace); | ||
748 | } | ||
749 | if (HasId) { | ||
750 | size += pb::CodedOutputStream.ComputeInt64Size(7, Id); | ||
751 | } | ||
752 | if (HasReplyId) { | ||
753 | size += pb::CodedOutputStream.ComputeInt64Size(8, ReplyId); | ||
754 | } | ||
755 | if (HasReturnStatus) { | ||
756 | size += pb::CodedOutputStream.ComputeEnumSize(1792, (int) ReturnStatus); | ||
757 | } | ||
758 | { | ||
759 | int dataSize = 0; | ||
760 | foreach (string element in MessageNamesList) { | ||
761 | dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | ||
762 | } | ||
763 | size += dataSize; | ||
764 | size += 1 * messageNames_.Count; | ||
765 | } | ||
766 | { | ||
767 | int dataSize = 0; | ||
768 | foreach (pb::ByteString element in MessageArgumentsList) { | ||
769 | dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); | ||
770 | } | ||
771 | size += dataSize; | ||
772 | size += 1 * messageArguments_.Count; | ||
773 | } | ||
774 | size += UnknownFields.SerializedSize; | ||
775 | memoizedSerializedSize = size; | ||
776 | return size; | ||
777 | } | ||
778 | } | ||
779 | |||
780 | public static ReadOnlyMessage ParseFrom(pb::ByteString data) { | ||
781 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
782 | } | ||
783 | public static ReadOnlyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
784 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
785 | } | ||
786 | public static ReadOnlyMessage ParseFrom(byte[] data) { | ||
787 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
788 | } | ||
789 | public static ReadOnlyMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
790 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
791 | } | ||
792 | public static ReadOnlyMessage ParseFrom(global::System.IO.Stream input) { | ||
793 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
794 | } | ||
795 | public static ReadOnlyMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
796 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
797 | } | ||
798 | public static ReadOnlyMessage ParseDelimitedFrom(global::System.IO.Stream input) { | ||
799 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
800 | } | ||
801 | public static ReadOnlyMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
802 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
803 | } | ||
804 | public static ReadOnlyMessage ParseFrom(pb::CodedInputStream input) { | ||
805 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
806 | } | ||
807 | public static ReadOnlyMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
808 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
809 | } | ||
810 | public static Builder CreateBuilder() { return new Builder(); } | ||
811 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
812 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
813 | public static Builder CreateBuilder(ReadOnlyMessage prototype) { | ||
814 | return (Builder) new Builder().MergeFrom(prototype); | ||
815 | } | ||
816 | |||
817 | public sealed partial class Builder : pb::GeneratedBuilder<ReadOnlyMessage, Builder> { | ||
818 | protected override Builder ThisBuilder { | ||
819 | get { return this; } | ||
820 | } | ||
821 | public Builder() {} | ||
822 | |||
823 | ReadOnlyMessage result = new ReadOnlyMessage(); | ||
824 | |||
825 | protected override ReadOnlyMessage MessageBeingBuilt { | ||
826 | get { return result; } | ||
827 | } | ||
828 | |||
829 | public override Builder Clear() { | ||
830 | result = new ReadOnlyMessage(); | ||
831 | return this; | ||
832 | } | ||
833 | |||
834 | public override Builder Clone() { | ||
835 | return new Builder().MergeFrom(result); | ||
836 | } | ||
837 | |||
838 | public override pbd::MessageDescriptor DescriptorForType { | ||
839 | get { return global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Descriptor; } | ||
840 | } | ||
841 | |||
842 | public override ReadOnlyMessage DefaultInstanceForType { | ||
843 | get { return global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.DefaultInstance; } | ||
844 | } | ||
845 | |||
846 | public override ReadOnlyMessage BuildPartial() { | ||
847 | if (result == null) { | ||
848 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
849 | } | ||
850 | result.messageNames_.MakeReadOnly(); | ||
851 | result.messageArguments_.MakeReadOnly(); | ||
852 | ReadOnlyMessage returnMe = result; | ||
853 | result = null; | ||
854 | return returnMe; | ||
855 | } | ||
856 | |||
857 | public override Builder MergeFrom(pb::IMessage other) { | ||
858 | if (other is ReadOnlyMessage) { | ||
859 | return MergeFrom((ReadOnlyMessage) other); | ||
860 | } else { | ||
861 | base.MergeFrom(other); | ||
862 | return this; | ||
863 | } | ||
864 | } | ||
865 | |||
866 | public override Builder MergeFrom(ReadOnlyMessage other) { | ||
867 | if (other == global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.DefaultInstance) return this; | ||
868 | if (other.HasSourceObject) { | ||
869 | SourceObject = other.SourceObject; | ||
870 | } | ||
871 | if (other.HasSourcePort) { | ||
872 | SourcePort = other.SourcePort; | ||
873 | } | ||
874 | if (other.HasSourceSpace) { | ||
875 | SourceSpace = other.SourceSpace; | ||
876 | } | ||
877 | if (other.HasDestinationObject) { | ||
878 | DestinationObject = other.DestinationObject; | ||
879 | } | ||
880 | if (other.HasDestinationPort) { | ||
881 | DestinationPort = other.DestinationPort; | ||
882 | } | ||
883 | if (other.HasDestinationSpace) { | ||
884 | DestinationSpace = other.DestinationSpace; | ||
885 | } | ||
886 | if (other.HasId) { | ||
887 | Id = other.Id; | ||
888 | } | ||
889 | if (other.HasReplyId) { | ||
890 | ReplyId = other.ReplyId; | ||
891 | } | ||
892 | if (other.HasReturnStatus) { | ||
893 | ReturnStatus = other.ReturnStatus; | ||
894 | } | ||
895 | if (other.messageNames_.Count != 0) { | ||
896 | base.AddRange(other.messageNames_, result.messageNames_); | ||
897 | } | ||
898 | if (other.messageArguments_.Count != 0) { | ||
899 | base.AddRange(other.messageArguments_, result.messageArguments_); | ||
900 | } | ||
901 | this.MergeUnknownFields(other.UnknownFields); | ||
902 | return this; | ||
903 | } | ||
904 | |||
905 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
906 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
907 | } | ||
908 | |||
909 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
910 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
911 | while (true) { | ||
912 | uint tag = input.ReadTag(); | ||
913 | switch (tag) { | ||
914 | case 0: { | ||
915 | if (unknownFields != null) { | ||
916 | this.UnknownFields = unknownFields.Build(); | ||
917 | } | ||
918 | return this; | ||
919 | } | ||
920 | default: { | ||
921 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
922 | if (unknownFields != null) { | ||
923 | this.UnknownFields = unknownFields.Build(); | ||
924 | } | ||
925 | return this; | ||
926 | } | ||
927 | if (unknownFields == null) { | ||
928 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
929 | } | ||
930 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
931 | break; | ||
932 | } | ||
933 | case 10: { | ||
934 | SourceObject = input.ReadBytes(); | ||
935 | break; | ||
936 | } | ||
937 | case 18: { | ||
938 | DestinationObject = input.ReadBytes(); | ||
939 | break; | ||
940 | } | ||
941 | case 24: { | ||
942 | SourcePort = input.ReadUInt32(); | ||
943 | break; | ||
944 | } | ||
945 | case 32: { | ||
946 | DestinationPort = input.ReadUInt32(); | ||
947 | break; | ||
948 | } | ||
949 | case 56: { | ||
950 | Id = input.ReadInt64(); | ||
951 | break; | ||
952 | } | ||
953 | case 64: { | ||
954 | ReplyId = input.ReadInt64(); | ||
955 | break; | ||
956 | } | ||
957 | case 74: { | ||
958 | AddMessageNames(input.ReadString()); | ||
959 | break; | ||
960 | } | ||
961 | case 82: { | ||
962 | AddMessageArguments(input.ReadBytes()); | ||
963 | break; | ||
964 | } | ||
965 | case 12290: { | ||
966 | SourceSpace = input.ReadBytes(); | ||
967 | break; | ||
968 | } | ||
969 | case 12298: { | ||
970 | DestinationSpace = input.ReadBytes(); | ||
971 | break; | ||
972 | } | ||
973 | case 14336: { | ||
974 | int rawValue = input.ReadEnum(); | ||
975 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus), rawValue)) { | ||
976 | if (unknownFields == null) { | ||
977 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
978 | } | ||
979 | unknownFields.MergeVarintField(1792, (ulong) rawValue); | ||
980 | } else { | ||
981 | ReturnStatus = (global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus) rawValue; | ||
982 | } | ||
983 | break; | ||
984 | } | ||
985 | } | ||
986 | } | ||
987 | } | ||
988 | |||
989 | |||
990 | public bool HasSourceObject { | ||
991 | get { return result.HasSourceObject; } | ||
992 | } | ||
993 | public pb::ByteString SourceObject { | ||
994 | get { return result.SourceObject; } | ||
995 | set { SetSourceObject(value); } | ||
996 | } | ||
997 | public Builder SetSourceObject(pb::ByteString value) { | ||
998 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
999 | result.hasSourceObject = true; | ||
1000 | result.sourceObject_ = value; | ||
1001 | return this; | ||
1002 | } | ||
1003 | public Builder ClearSourceObject() { | ||
1004 | result.hasSourceObject = false; | ||
1005 | result.sourceObject_ = pb::ByteString.Empty; | ||
1006 | return this; | ||
1007 | } | ||
1008 | |||
1009 | public bool HasSourcePort { | ||
1010 | get { return result.HasSourcePort; } | ||
1011 | } | ||
1012 | [global::System.CLSCompliant(false)] | ||
1013 | public uint SourcePort { | ||
1014 | get { return result.SourcePort; } | ||
1015 | set { SetSourcePort(value); } | ||
1016 | } | ||
1017 | [global::System.CLSCompliant(false)] | ||
1018 | public Builder SetSourcePort(uint value) { | ||
1019 | result.hasSourcePort = true; | ||
1020 | result.sourcePort_ = value; | ||
1021 | return this; | ||
1022 | } | ||
1023 | public Builder ClearSourcePort() { | ||
1024 | result.hasSourcePort = false; | ||
1025 | result.sourcePort_ = 0; | ||
1026 | return this; | ||
1027 | } | ||
1028 | |||
1029 | public bool HasSourceSpace { | ||
1030 | get { return result.HasSourceSpace; } | ||
1031 | } | ||
1032 | public pb::ByteString SourceSpace { | ||
1033 | get { return result.SourceSpace; } | ||
1034 | set { SetSourceSpace(value); } | ||
1035 | } | ||
1036 | public Builder SetSourceSpace(pb::ByteString value) { | ||
1037 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1038 | result.hasSourceSpace = true; | ||
1039 | result.sourceSpace_ = value; | ||
1040 | return this; | ||
1041 | } | ||
1042 | public Builder ClearSourceSpace() { | ||
1043 | result.hasSourceSpace = false; | ||
1044 | result.sourceSpace_ = pb::ByteString.Empty; | ||
1045 | return this; | ||
1046 | } | ||
1047 | |||
1048 | public bool HasDestinationObject { | ||
1049 | get { return result.HasDestinationObject; } | ||
1050 | } | ||
1051 | public pb::ByteString DestinationObject { | ||
1052 | get { return result.DestinationObject; } | ||
1053 | set { SetDestinationObject(value); } | ||
1054 | } | ||
1055 | public Builder SetDestinationObject(pb::ByteString value) { | ||
1056 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1057 | result.hasDestinationObject = true; | ||
1058 | result.destinationObject_ = value; | ||
1059 | return this; | ||
1060 | } | ||
1061 | public Builder ClearDestinationObject() { | ||
1062 | result.hasDestinationObject = false; | ||
1063 | result.destinationObject_ = pb::ByteString.Empty; | ||
1064 | return this; | ||
1065 | } | ||
1066 | |||
1067 | public bool HasDestinationPort { | ||
1068 | get { return result.HasDestinationPort; } | ||
1069 | } | ||
1070 | [global::System.CLSCompliant(false)] | ||
1071 | public uint DestinationPort { | ||
1072 | get { return result.DestinationPort; } | ||
1073 | set { SetDestinationPort(value); } | ||
1074 | } | ||
1075 | [global::System.CLSCompliant(false)] | ||
1076 | public Builder SetDestinationPort(uint value) { | ||
1077 | result.hasDestinationPort = true; | ||
1078 | result.destinationPort_ = value; | ||
1079 | return this; | ||
1080 | } | ||
1081 | public Builder ClearDestinationPort() { | ||
1082 | result.hasDestinationPort = false; | ||
1083 | result.destinationPort_ = 0; | ||
1084 | return this; | ||
1085 | } | ||
1086 | |||
1087 | public bool HasDestinationSpace { | ||
1088 | get { return result.HasDestinationSpace; } | ||
1089 | } | ||
1090 | public pb::ByteString DestinationSpace { | ||
1091 | get { return result.DestinationSpace; } | ||
1092 | set { SetDestinationSpace(value); } | ||
1093 | } | ||
1094 | public Builder SetDestinationSpace(pb::ByteString value) { | ||
1095 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1096 | result.hasDestinationSpace = true; | ||
1097 | result.destinationSpace_ = value; | ||
1098 | return this; | ||
1099 | } | ||
1100 | public Builder ClearDestinationSpace() { | ||
1101 | result.hasDestinationSpace = false; | ||
1102 | result.destinationSpace_ = pb::ByteString.Empty; | ||
1103 | return this; | ||
1104 | } | ||
1105 | |||
1106 | public bool HasId { | ||
1107 | get { return result.HasId; } | ||
1108 | } | ||
1109 | public long Id { | ||
1110 | get { return result.Id; } | ||
1111 | set { SetId(value); } | ||
1112 | } | ||
1113 | public Builder SetId(long value) { | ||
1114 | result.hasId = true; | ||
1115 | result.id_ = value; | ||
1116 | return this; | ||
1117 | } | ||
1118 | public Builder ClearId() { | ||
1119 | result.hasId = false; | ||
1120 | result.id_ = 0L; | ||
1121 | return this; | ||
1122 | } | ||
1123 | |||
1124 | public bool HasReplyId { | ||
1125 | get { return result.HasReplyId; } | ||
1126 | } | ||
1127 | public long ReplyId { | ||
1128 | get { return result.ReplyId; } | ||
1129 | set { SetReplyId(value); } | ||
1130 | } | ||
1131 | public Builder SetReplyId(long value) { | ||
1132 | result.hasReplyId = true; | ||
1133 | result.replyId_ = value; | ||
1134 | return this; | ||
1135 | } | ||
1136 | public Builder ClearReplyId() { | ||
1137 | result.hasReplyId = false; | ||
1138 | result.replyId_ = 0L; | ||
1139 | return this; | ||
1140 | } | ||
1141 | |||
1142 | public bool HasReturnStatus { | ||
1143 | get { return result.HasReturnStatus; } | ||
1144 | } | ||
1145 | public global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus ReturnStatus { | ||
1146 | get { return result.ReturnStatus; } | ||
1147 | set { SetReturnStatus(value); } | ||
1148 | } | ||
1149 | public Builder SetReturnStatus(global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus value) { | ||
1150 | result.hasReturnStatus = true; | ||
1151 | result.returnStatus_ = value; | ||
1152 | return this; | ||
1153 | } | ||
1154 | public Builder ClearReturnStatus() { | ||
1155 | result.hasReturnStatus = false; | ||
1156 | result.returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS; | ||
1157 | return this; | ||
1158 | } | ||
1159 | |||
1160 | public pbc::IPopsicleList<string> MessageNamesList { | ||
1161 | get { return result.messageNames_; } | ||
1162 | } | ||
1163 | public int MessageNamesCount { | ||
1164 | get { return result.MessageNamesCount; } | ||
1165 | } | ||
1166 | public string GetMessageNames(int index) { | ||
1167 | return result.GetMessageNames(index); | ||
1168 | } | ||
1169 | public Builder SetMessageNames(int index, string value) { | ||
1170 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1171 | result.messageNames_[index] = value; | ||
1172 | return this; | ||
1173 | } | ||
1174 | public Builder AddMessageNames(string value) { | ||
1175 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1176 | result.messageNames_.Add(value); | ||
1177 | return this; | ||
1178 | } | ||
1179 | public Builder AddRangeMessageNames(scg::IEnumerable<string> values) { | ||
1180 | base.AddRange(values, result.messageNames_); | ||
1181 | return this; | ||
1182 | } | ||
1183 | public Builder ClearMessageNames() { | ||
1184 | result.messageNames_.Clear(); | ||
1185 | return this; | ||
1186 | } | ||
1187 | |||
1188 | public pbc::IPopsicleList<pb::ByteString> MessageArgumentsList { | ||
1189 | get { return result.messageArguments_; } | ||
1190 | } | ||
1191 | public int MessageArgumentsCount { | ||
1192 | get { return result.MessageArgumentsCount; } | ||
1193 | } | ||
1194 | public pb::ByteString GetMessageArguments(int index) { | ||
1195 | return result.GetMessageArguments(index); | ||
1196 | } | ||
1197 | public Builder SetMessageArguments(int index, pb::ByteString value) { | ||
1198 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1199 | result.messageArguments_[index] = value; | ||
1200 | return this; | ||
1201 | } | ||
1202 | public Builder AddMessageArguments(pb::ByteString value) { | ||
1203 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1204 | result.messageArguments_.Add(value); | ||
1205 | return this; | ||
1206 | } | ||
1207 | public Builder AddRangeMessageArguments(scg::IEnumerable<pb::ByteString> values) { | ||
1208 | base.AddRange(values, result.messageArguments_); | ||
1209 | return this; | ||
1210 | } | ||
1211 | public Builder ClearMessageArguments() { | ||
1212 | result.messageArguments_.Clear(); | ||
1213 | return this; | ||
1214 | } | ||
1215 | } | ||
1216 | static ReadOnlyMessage() { | ||
1217 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
1218 | } | ||
1219 | } | ||
1220 | |||
1221 | public sealed partial class SpaceServices : pb::GeneratedMessage<SpaceServices, SpaceServices.Builder> { | ||
1222 | private static readonly SpaceServices defaultInstance = new Builder().BuildPartial(); | ||
1223 | public static SpaceServices DefaultInstance { | ||
1224 | get { return defaultInstance; } | ||
1225 | } | ||
1226 | |||
1227 | public override SpaceServices DefaultInstanceForType { | ||
1228 | get { return defaultInstance; } | ||
1229 | } | ||
1230 | |||
1231 | protected override SpaceServices ThisMessage { | ||
1232 | get { return this; } | ||
1233 | } | ||
1234 | |||
1235 | public static pbd::MessageDescriptor Descriptor { | ||
1236 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__Descriptor; } | ||
1237 | } | ||
1238 | |||
1239 | protected override pb::FieldAccess.FieldAccessorTable<SpaceServices, SpaceServices.Builder> InternalFieldAccessors { | ||
1240 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_SpaceServices__FieldAccessorTable; } | ||
1241 | } | ||
1242 | |||
1243 | public const int RegistrationPortFieldNumber = 33; | ||
1244 | private bool hasRegistrationPort; | ||
1245 | private uint registrationPort_ = 0; | ||
1246 | public bool HasRegistrationPort { | ||
1247 | get { return hasRegistrationPort; } | ||
1248 | } | ||
1249 | [global::System.CLSCompliant(false)] | ||
1250 | public uint RegistrationPort { | ||
1251 | get { return registrationPort_; } | ||
1252 | } | ||
1253 | |||
1254 | public const int LocPortFieldNumber = 34; | ||
1255 | private bool hasLocPort; | ||
1256 | private uint locPort_ = 0; | ||
1257 | public bool HasLocPort { | ||
1258 | get { return hasLocPort; } | ||
1259 | } | ||
1260 | [global::System.CLSCompliant(false)] | ||
1261 | public uint LocPort { | ||
1262 | get { return locPort_; } | ||
1263 | } | ||
1264 | |||
1265 | public const int GeomPortFieldNumber = 35; | ||
1266 | private bool hasGeomPort; | ||
1267 | private uint geomPort_ = 0; | ||
1268 | public bool HasGeomPort { | ||
1269 | get { return hasGeomPort; } | ||
1270 | } | ||
1271 | [global::System.CLSCompliant(false)] | ||
1272 | public uint GeomPort { | ||
1273 | get { return geomPort_; } | ||
1274 | } | ||
1275 | |||
1276 | public const int OsegPortFieldNumber = 36; | ||
1277 | private bool hasOsegPort; | ||
1278 | private uint osegPort_ = 0; | ||
1279 | public bool HasOsegPort { | ||
1280 | get { return hasOsegPort; } | ||
1281 | } | ||
1282 | [global::System.CLSCompliant(false)] | ||
1283 | public uint OsegPort { | ||
1284 | get { return osegPort_; } | ||
1285 | } | ||
1286 | |||
1287 | public const int CsegPortFieldNumber = 37; | ||
1288 | private bool hasCsegPort; | ||
1289 | private uint csegPort_ = 0; | ||
1290 | public bool HasCsegPort { | ||
1291 | get { return hasCsegPort; } | ||
1292 | } | ||
1293 | [global::System.CLSCompliant(false)] | ||
1294 | public uint CsegPort { | ||
1295 | get { return csegPort_; } | ||
1296 | } | ||
1297 | |||
1298 | public const int RouterPortFieldNumber = 38; | ||
1299 | private bool hasRouterPort; | ||
1300 | private uint routerPort_ = 0; | ||
1301 | public bool HasRouterPort { | ||
1302 | get { return hasRouterPort; } | ||
1303 | } | ||
1304 | [global::System.CLSCompliant(false)] | ||
1305 | public uint RouterPort { | ||
1306 | get { return routerPort_; } | ||
1307 | } | ||
1308 | |||
1309 | public const int PreConnectionBufferFieldNumber = 64; | ||
1310 | private bool hasPreConnectionBuffer; | ||
1311 | private ulong preConnectionBuffer_ = 0UL; | ||
1312 | public bool HasPreConnectionBuffer { | ||
1313 | get { return hasPreConnectionBuffer; } | ||
1314 | } | ||
1315 | [global::System.CLSCompliant(false)] | ||
1316 | public ulong PreConnectionBuffer { | ||
1317 | get { return preConnectionBuffer_; } | ||
1318 | } | ||
1319 | |||
1320 | public const int MaxPreConnectionMessagesFieldNumber = 65; | ||
1321 | private bool hasMaxPreConnectionMessages; | ||
1322 | private ulong maxPreConnectionMessages_ = 0UL; | ||
1323 | public bool HasMaxPreConnectionMessages { | ||
1324 | get { return hasMaxPreConnectionMessages; } | ||
1325 | } | ||
1326 | [global::System.CLSCompliant(false)] | ||
1327 | public ulong MaxPreConnectionMessages { | ||
1328 | get { return maxPreConnectionMessages_; } | ||
1329 | } | ||
1330 | |||
1331 | public override bool IsInitialized { | ||
1332 | get { | ||
1333 | return true; | ||
1334 | } | ||
1335 | } | ||
1336 | |||
1337 | public override void WriteTo(pb::CodedOutputStream output) { | ||
1338 | if (HasRegistrationPort) { | ||
1339 | output.WriteUInt32(33, RegistrationPort); | ||
1340 | } | ||
1341 | if (HasLocPort) { | ||
1342 | output.WriteUInt32(34, LocPort); | ||
1343 | } | ||
1344 | if (HasGeomPort) { | ||
1345 | output.WriteUInt32(35, GeomPort); | ||
1346 | } | ||
1347 | if (HasOsegPort) { | ||
1348 | output.WriteUInt32(36, OsegPort); | ||
1349 | } | ||
1350 | if (HasCsegPort) { | ||
1351 | output.WriteUInt32(37, CsegPort); | ||
1352 | } | ||
1353 | if (HasRouterPort) { | ||
1354 | output.WriteUInt32(38, RouterPort); | ||
1355 | } | ||
1356 | if (HasPreConnectionBuffer) { | ||
1357 | output.WriteUInt64(64, PreConnectionBuffer); | ||
1358 | } | ||
1359 | if (HasMaxPreConnectionMessages) { | ||
1360 | output.WriteUInt64(65, MaxPreConnectionMessages); | ||
1361 | } | ||
1362 | UnknownFields.WriteTo(output); | ||
1363 | } | ||
1364 | |||
1365 | private int memoizedSerializedSize = -1; | ||
1366 | public override int SerializedSize { | ||
1367 | get { | ||
1368 | int size = memoizedSerializedSize; | ||
1369 | if (size != -1) return size; | ||
1370 | |||
1371 | size = 0; | ||
1372 | if (HasRegistrationPort) { | ||
1373 | size += pb::CodedOutputStream.ComputeUInt32Size(33, RegistrationPort); | ||
1374 | } | ||
1375 | if (HasLocPort) { | ||
1376 | size += pb::CodedOutputStream.ComputeUInt32Size(34, LocPort); | ||
1377 | } | ||
1378 | if (HasGeomPort) { | ||
1379 | size += pb::CodedOutputStream.ComputeUInt32Size(35, GeomPort); | ||
1380 | } | ||
1381 | if (HasOsegPort) { | ||
1382 | size += pb::CodedOutputStream.ComputeUInt32Size(36, OsegPort); | ||
1383 | } | ||
1384 | if (HasCsegPort) { | ||
1385 | size += pb::CodedOutputStream.ComputeUInt32Size(37, CsegPort); | ||
1386 | } | ||
1387 | if (HasRouterPort) { | ||
1388 | size += pb::CodedOutputStream.ComputeUInt32Size(38, RouterPort); | ||
1389 | } | ||
1390 | if (HasPreConnectionBuffer) { | ||
1391 | size += pb::CodedOutputStream.ComputeUInt64Size(64, PreConnectionBuffer); | ||
1392 | } | ||
1393 | if (HasMaxPreConnectionMessages) { | ||
1394 | size += pb::CodedOutputStream.ComputeUInt64Size(65, MaxPreConnectionMessages); | ||
1395 | } | ||
1396 | size += UnknownFields.SerializedSize; | ||
1397 | memoizedSerializedSize = size; | ||
1398 | return size; | ||
1399 | } | ||
1400 | } | ||
1401 | |||
1402 | public static SpaceServices ParseFrom(pb::ByteString data) { | ||
1403 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1404 | } | ||
1405 | public static SpaceServices ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
1406 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1407 | } | ||
1408 | public static SpaceServices ParseFrom(byte[] data) { | ||
1409 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1410 | } | ||
1411 | public static SpaceServices ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
1412 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1413 | } | ||
1414 | public static SpaceServices ParseFrom(global::System.IO.Stream input) { | ||
1415 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1416 | } | ||
1417 | public static SpaceServices ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1418 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1419 | } | ||
1420 | public static SpaceServices ParseDelimitedFrom(global::System.IO.Stream input) { | ||
1421 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
1422 | } | ||
1423 | public static SpaceServices ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1424 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
1425 | } | ||
1426 | public static SpaceServices ParseFrom(pb::CodedInputStream input) { | ||
1427 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1428 | } | ||
1429 | public static SpaceServices ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1430 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1431 | } | ||
1432 | public static Builder CreateBuilder() { return new Builder(); } | ||
1433 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
1434 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
1435 | public static Builder CreateBuilder(SpaceServices prototype) { | ||
1436 | return (Builder) new Builder().MergeFrom(prototype); | ||
1437 | } | ||
1438 | |||
1439 | public sealed partial class Builder : pb::GeneratedBuilder<SpaceServices, Builder> { | ||
1440 | protected override Builder ThisBuilder { | ||
1441 | get { return this; } | ||
1442 | } | ||
1443 | public Builder() {} | ||
1444 | |||
1445 | SpaceServices result = new SpaceServices(); | ||
1446 | |||
1447 | protected override SpaceServices MessageBeingBuilt { | ||
1448 | get { return result; } | ||
1449 | } | ||
1450 | |||
1451 | public override Builder Clear() { | ||
1452 | result = new SpaceServices(); | ||
1453 | return this; | ||
1454 | } | ||
1455 | |||
1456 | public override Builder Clone() { | ||
1457 | return new Builder().MergeFrom(result); | ||
1458 | } | ||
1459 | |||
1460 | public override pbd::MessageDescriptor DescriptorForType { | ||
1461 | get { return global::Sirikata.Protocol._PBJ_Internal.SpaceServices.Descriptor; } | ||
1462 | } | ||
1463 | |||
1464 | public override SpaceServices DefaultInstanceForType { | ||
1465 | get { return global::Sirikata.Protocol._PBJ_Internal.SpaceServices.DefaultInstance; } | ||
1466 | } | ||
1467 | |||
1468 | public override SpaceServices BuildPartial() { | ||
1469 | if (result == null) { | ||
1470 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
1471 | } | ||
1472 | SpaceServices returnMe = result; | ||
1473 | result = null; | ||
1474 | return returnMe; | ||
1475 | } | ||
1476 | |||
1477 | public override Builder MergeFrom(pb::IMessage other) { | ||
1478 | if (other is SpaceServices) { | ||
1479 | return MergeFrom((SpaceServices) other); | ||
1480 | } else { | ||
1481 | base.MergeFrom(other); | ||
1482 | return this; | ||
1483 | } | ||
1484 | } | ||
1485 | |||
1486 | public override Builder MergeFrom(SpaceServices other) { | ||
1487 | if (other == global::Sirikata.Protocol._PBJ_Internal.SpaceServices.DefaultInstance) return this; | ||
1488 | if (other.HasRegistrationPort) { | ||
1489 | RegistrationPort = other.RegistrationPort; | ||
1490 | } | ||
1491 | if (other.HasLocPort) { | ||
1492 | LocPort = other.LocPort; | ||
1493 | } | ||
1494 | if (other.HasGeomPort) { | ||
1495 | GeomPort = other.GeomPort; | ||
1496 | } | ||
1497 | if (other.HasOsegPort) { | ||
1498 | OsegPort = other.OsegPort; | ||
1499 | } | ||
1500 | if (other.HasCsegPort) { | ||
1501 | CsegPort = other.CsegPort; | ||
1502 | } | ||
1503 | if (other.HasRouterPort) { | ||
1504 | RouterPort = other.RouterPort; | ||
1505 | } | ||
1506 | if (other.HasPreConnectionBuffer) { | ||
1507 | PreConnectionBuffer = other.PreConnectionBuffer; | ||
1508 | } | ||
1509 | if (other.HasMaxPreConnectionMessages) { | ||
1510 | MaxPreConnectionMessages = other.MaxPreConnectionMessages; | ||
1511 | } | ||
1512 | this.MergeUnknownFields(other.UnknownFields); | ||
1513 | return this; | ||
1514 | } | ||
1515 | |||
1516 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
1517 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
1518 | } | ||
1519 | |||
1520 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1521 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
1522 | while (true) { | ||
1523 | uint tag = input.ReadTag(); | ||
1524 | switch (tag) { | ||
1525 | case 0: { | ||
1526 | if (unknownFields != null) { | ||
1527 | this.UnknownFields = unknownFields.Build(); | ||
1528 | } | ||
1529 | return this; | ||
1530 | } | ||
1531 | default: { | ||
1532 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
1533 | if (unknownFields != null) { | ||
1534 | this.UnknownFields = unknownFields.Build(); | ||
1535 | } | ||
1536 | return this; | ||
1537 | } | ||
1538 | if (unknownFields == null) { | ||
1539 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
1540 | } | ||
1541 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
1542 | break; | ||
1543 | } | ||
1544 | case 264: { | ||
1545 | RegistrationPort = input.ReadUInt32(); | ||
1546 | break; | ||
1547 | } | ||
1548 | case 272: { | ||
1549 | LocPort = input.ReadUInt32(); | ||
1550 | break; | ||
1551 | } | ||
1552 | case 280: { | ||
1553 | GeomPort = input.ReadUInt32(); | ||
1554 | break; | ||
1555 | } | ||
1556 | case 288: { | ||
1557 | OsegPort = input.ReadUInt32(); | ||
1558 | break; | ||
1559 | } | ||
1560 | case 296: { | ||
1561 | CsegPort = input.ReadUInt32(); | ||
1562 | break; | ||
1563 | } | ||
1564 | case 304: { | ||
1565 | RouterPort = input.ReadUInt32(); | ||
1566 | break; | ||
1567 | } | ||
1568 | case 512: { | ||
1569 | PreConnectionBuffer = input.ReadUInt64(); | ||
1570 | break; | ||
1571 | } | ||
1572 | case 520: { | ||
1573 | MaxPreConnectionMessages = input.ReadUInt64(); | ||
1574 | break; | ||
1575 | } | ||
1576 | } | ||
1577 | } | ||
1578 | } | ||
1579 | |||
1580 | |||
1581 | public bool HasRegistrationPort { | ||
1582 | get { return result.HasRegistrationPort; } | ||
1583 | } | ||
1584 | [global::System.CLSCompliant(false)] | ||
1585 | public uint RegistrationPort { | ||
1586 | get { return result.RegistrationPort; } | ||
1587 | set { SetRegistrationPort(value); } | ||
1588 | } | ||
1589 | [global::System.CLSCompliant(false)] | ||
1590 | public Builder SetRegistrationPort(uint value) { | ||
1591 | result.hasRegistrationPort = true; | ||
1592 | result.registrationPort_ = value; | ||
1593 | return this; | ||
1594 | } | ||
1595 | public Builder ClearRegistrationPort() { | ||
1596 | result.hasRegistrationPort = false; | ||
1597 | result.registrationPort_ = 0; | ||
1598 | return this; | ||
1599 | } | ||
1600 | |||
1601 | public bool HasLocPort { | ||
1602 | get { return result.HasLocPort; } | ||
1603 | } | ||
1604 | [global::System.CLSCompliant(false)] | ||
1605 | public uint LocPort { | ||
1606 | get { return result.LocPort; } | ||
1607 | set { SetLocPort(value); } | ||
1608 | } | ||
1609 | [global::System.CLSCompliant(false)] | ||
1610 | public Builder SetLocPort(uint value) { | ||
1611 | result.hasLocPort = true; | ||
1612 | result.locPort_ = value; | ||
1613 | return this; | ||
1614 | } | ||
1615 | public Builder ClearLocPort() { | ||
1616 | result.hasLocPort = false; | ||
1617 | result.locPort_ = 0; | ||
1618 | return this; | ||
1619 | } | ||
1620 | |||
1621 | public bool HasGeomPort { | ||
1622 | get { return result.HasGeomPort; } | ||
1623 | } | ||
1624 | [global::System.CLSCompliant(false)] | ||
1625 | public uint GeomPort { | ||
1626 | get { return result.GeomPort; } | ||
1627 | set { SetGeomPort(value); } | ||
1628 | } | ||
1629 | [global::System.CLSCompliant(false)] | ||
1630 | public Builder SetGeomPort(uint value) { | ||
1631 | result.hasGeomPort = true; | ||
1632 | result.geomPort_ = value; | ||
1633 | return this; | ||
1634 | } | ||
1635 | public Builder ClearGeomPort() { | ||
1636 | result.hasGeomPort = false; | ||
1637 | result.geomPort_ = 0; | ||
1638 | return this; | ||
1639 | } | ||
1640 | |||
1641 | public bool HasOsegPort { | ||
1642 | get { return result.HasOsegPort; } | ||
1643 | } | ||
1644 | [global::System.CLSCompliant(false)] | ||
1645 | public uint OsegPort { | ||
1646 | get { return result.OsegPort; } | ||
1647 | set { SetOsegPort(value); } | ||
1648 | } | ||
1649 | [global::System.CLSCompliant(false)] | ||
1650 | public Builder SetOsegPort(uint value) { | ||
1651 | result.hasOsegPort = true; | ||
1652 | result.osegPort_ = value; | ||
1653 | return this; | ||
1654 | } | ||
1655 | public Builder ClearOsegPort() { | ||
1656 | result.hasOsegPort = false; | ||
1657 | result.osegPort_ = 0; | ||
1658 | return this; | ||
1659 | } | ||
1660 | |||
1661 | public bool HasCsegPort { | ||
1662 | get { return result.HasCsegPort; } | ||
1663 | } | ||
1664 | [global::System.CLSCompliant(false)] | ||
1665 | public uint CsegPort { | ||
1666 | get { return result.CsegPort; } | ||
1667 | set { SetCsegPort(value); } | ||
1668 | } | ||
1669 | [global::System.CLSCompliant(false)] | ||
1670 | public Builder SetCsegPort(uint value) { | ||
1671 | result.hasCsegPort = true; | ||
1672 | result.csegPort_ = value; | ||
1673 | return this; | ||
1674 | } | ||
1675 | public Builder ClearCsegPort() { | ||
1676 | result.hasCsegPort = false; | ||
1677 | result.csegPort_ = 0; | ||
1678 | return this; | ||
1679 | } | ||
1680 | |||
1681 | public bool HasRouterPort { | ||
1682 | get { return result.HasRouterPort; } | ||
1683 | } | ||
1684 | [global::System.CLSCompliant(false)] | ||
1685 | public uint RouterPort { | ||
1686 | get { return result.RouterPort; } | ||
1687 | set { SetRouterPort(value); } | ||
1688 | } | ||
1689 | [global::System.CLSCompliant(false)] | ||
1690 | public Builder SetRouterPort(uint value) { | ||
1691 | result.hasRouterPort = true; | ||
1692 | result.routerPort_ = value; | ||
1693 | return this; | ||
1694 | } | ||
1695 | public Builder ClearRouterPort() { | ||
1696 | result.hasRouterPort = false; | ||
1697 | result.routerPort_ = 0; | ||
1698 | return this; | ||
1699 | } | ||
1700 | |||
1701 | public bool HasPreConnectionBuffer { | ||
1702 | get { return result.HasPreConnectionBuffer; } | ||
1703 | } | ||
1704 | [global::System.CLSCompliant(false)] | ||
1705 | public ulong PreConnectionBuffer { | ||
1706 | get { return result.PreConnectionBuffer; } | ||
1707 | set { SetPreConnectionBuffer(value); } | ||
1708 | } | ||
1709 | [global::System.CLSCompliant(false)] | ||
1710 | public Builder SetPreConnectionBuffer(ulong value) { | ||
1711 | result.hasPreConnectionBuffer = true; | ||
1712 | result.preConnectionBuffer_ = value; | ||
1713 | return this; | ||
1714 | } | ||
1715 | public Builder ClearPreConnectionBuffer() { | ||
1716 | result.hasPreConnectionBuffer = false; | ||
1717 | result.preConnectionBuffer_ = 0UL; | ||
1718 | return this; | ||
1719 | } | ||
1720 | |||
1721 | public bool HasMaxPreConnectionMessages { | ||
1722 | get { return result.HasMaxPreConnectionMessages; } | ||
1723 | } | ||
1724 | [global::System.CLSCompliant(false)] | ||
1725 | public ulong MaxPreConnectionMessages { | ||
1726 | get { return result.MaxPreConnectionMessages; } | ||
1727 | set { SetMaxPreConnectionMessages(value); } | ||
1728 | } | ||
1729 | [global::System.CLSCompliant(false)] | ||
1730 | public Builder SetMaxPreConnectionMessages(ulong value) { | ||
1731 | result.hasMaxPreConnectionMessages = true; | ||
1732 | result.maxPreConnectionMessages_ = value; | ||
1733 | return this; | ||
1734 | } | ||
1735 | public Builder ClearMaxPreConnectionMessages() { | ||
1736 | result.hasMaxPreConnectionMessages = false; | ||
1737 | result.maxPreConnectionMessages_ = 0UL; | ||
1738 | return this; | ||
1739 | } | ||
1740 | } | ||
1741 | static SpaceServices() { | ||
1742 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
1743 | } | ||
1744 | } | ||
1745 | |||
1746 | public sealed partial class ObjLoc : pb::GeneratedMessage<ObjLoc, ObjLoc.Builder> { | ||
1747 | private static readonly ObjLoc defaultInstance = new Builder().BuildPartial(); | ||
1748 | public static ObjLoc DefaultInstance { | ||
1749 | get { return defaultInstance; } | ||
1750 | } | ||
1751 | |||
1752 | public override ObjLoc DefaultInstanceForType { | ||
1753 | get { return defaultInstance; } | ||
1754 | } | ||
1755 | |||
1756 | protected override ObjLoc ThisMessage { | ||
1757 | get { return this; } | ||
1758 | } | ||
1759 | |||
1760 | public static pbd::MessageDescriptor Descriptor { | ||
1761 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__Descriptor; } | ||
1762 | } | ||
1763 | |||
1764 | protected override pb::FieldAccess.FieldAccessorTable<ObjLoc, ObjLoc.Builder> InternalFieldAccessors { | ||
1765 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ObjLoc__FieldAccessorTable; } | ||
1766 | } | ||
1767 | |||
1768 | #region Nested types | ||
1769 | public static class Types { | ||
1770 | public enum UpdateFlags { | ||
1771 | FORCE = 1, | ||
1772 | } | ||
1773 | |||
1774 | } | ||
1775 | #endregion | ||
1776 | |||
1777 | public const int TimestampFieldNumber = 2; | ||
1778 | private bool hasTimestamp; | ||
1779 | private ulong timestamp_ = 0; | ||
1780 | public bool HasTimestamp { | ||
1781 | get { return hasTimestamp; } | ||
1782 | } | ||
1783 | [global::System.CLSCompliant(false)] | ||
1784 | public ulong Timestamp { | ||
1785 | get { return timestamp_; } | ||
1786 | } | ||
1787 | |||
1788 | public const int PositionFieldNumber = 3; | ||
1789 | private int positionMemoizedSerializedSize; | ||
1790 | private pbc::PopsicleList<double> position_ = new pbc::PopsicleList<double>(); | ||
1791 | public scg::IList<double> PositionList { | ||
1792 | get { return pbc::Lists.AsReadOnly(position_); } | ||
1793 | } | ||
1794 | public int PositionCount { | ||
1795 | get { return position_.Count; } | ||
1796 | } | ||
1797 | public double GetPosition(int index) { | ||
1798 | return position_[index]; | ||
1799 | } | ||
1800 | |||
1801 | public const int OrientationFieldNumber = 4; | ||
1802 | private int orientationMemoizedSerializedSize; | ||
1803 | private pbc::PopsicleList<float> orientation_ = new pbc::PopsicleList<float>(); | ||
1804 | public scg::IList<float> OrientationList { | ||
1805 | get { return pbc::Lists.AsReadOnly(orientation_); } | ||
1806 | } | ||
1807 | public int OrientationCount { | ||
1808 | get { return orientation_.Count; } | ||
1809 | } | ||
1810 | public float GetOrientation(int index) { | ||
1811 | return orientation_[index]; | ||
1812 | } | ||
1813 | |||
1814 | public const int VelocityFieldNumber = 5; | ||
1815 | private int velocityMemoizedSerializedSize; | ||
1816 | private pbc::PopsicleList<float> velocity_ = new pbc::PopsicleList<float>(); | ||
1817 | public scg::IList<float> VelocityList { | ||
1818 | get { return pbc::Lists.AsReadOnly(velocity_); } | ||
1819 | } | ||
1820 | public int VelocityCount { | ||
1821 | get { return velocity_.Count; } | ||
1822 | } | ||
1823 | public float GetVelocity(int index) { | ||
1824 | return velocity_[index]; | ||
1825 | } | ||
1826 | |||
1827 | public const int RotationalAxisFieldNumber = 7; | ||
1828 | private int rotationalAxisMemoizedSerializedSize; | ||
1829 | private pbc::PopsicleList<float> rotationalAxis_ = new pbc::PopsicleList<float>(); | ||
1830 | public scg::IList<float> RotationalAxisList { | ||
1831 | get { return pbc::Lists.AsReadOnly(rotationalAxis_); } | ||
1832 | } | ||
1833 | public int RotationalAxisCount { | ||
1834 | get { return rotationalAxis_.Count; } | ||
1835 | } | ||
1836 | public float GetRotationalAxis(int index) { | ||
1837 | return rotationalAxis_[index]; | ||
1838 | } | ||
1839 | |||
1840 | public const int AngularSpeedFieldNumber = 8; | ||
1841 | private bool hasAngularSpeed; | ||
1842 | private float angularSpeed_ = 0F; | ||
1843 | public bool HasAngularSpeed { | ||
1844 | get { return hasAngularSpeed; } | ||
1845 | } | ||
1846 | public float AngularSpeed { | ||
1847 | get { return angularSpeed_; } | ||
1848 | } | ||
1849 | |||
1850 | public const int UpdateFlagsFieldNumber = 6; | ||
1851 | private bool hasUpdateFlags; | ||
1852 | private uint updateFlags_ = 0; | ||
1853 | public bool HasUpdateFlags { | ||
1854 | get { return hasUpdateFlags; } | ||
1855 | } | ||
1856 | [global::System.CLSCompliant(false)] | ||
1857 | public uint UpdateFlags { | ||
1858 | get { return updateFlags_; } | ||
1859 | } | ||
1860 | |||
1861 | public override bool IsInitialized { | ||
1862 | get { | ||
1863 | return true; | ||
1864 | } | ||
1865 | } | ||
1866 | |||
1867 | public override void WriteTo(pb::CodedOutputStream output) { | ||
1868 | if (HasTimestamp) { | ||
1869 | output.WriteFixed64(2, Timestamp); | ||
1870 | } | ||
1871 | if (position_.Count > 0) { | ||
1872 | output.WriteRawVarint32(26); | ||
1873 | output.WriteRawVarint32((uint) positionMemoizedSerializedSize); | ||
1874 | foreach (double element in position_) { | ||
1875 | output.WriteDoubleNoTag(element); | ||
1876 | } | ||
1877 | } | ||
1878 | if (orientation_.Count > 0) { | ||
1879 | output.WriteRawVarint32(34); | ||
1880 | output.WriteRawVarint32((uint) orientationMemoizedSerializedSize); | ||
1881 | foreach (float element in orientation_) { | ||
1882 | output.WriteFloatNoTag(element); | ||
1883 | } | ||
1884 | } | ||
1885 | if (velocity_.Count > 0) { | ||
1886 | output.WriteRawVarint32(42); | ||
1887 | output.WriteRawVarint32((uint) velocityMemoizedSerializedSize); | ||
1888 | foreach (float element in velocity_) { | ||
1889 | output.WriteFloatNoTag(element); | ||
1890 | } | ||
1891 | } | ||
1892 | if (HasUpdateFlags) { | ||
1893 | output.WriteUInt32(6, UpdateFlags); | ||
1894 | } | ||
1895 | if (rotationalAxis_.Count > 0) { | ||
1896 | output.WriteRawVarint32(58); | ||
1897 | output.WriteRawVarint32((uint) rotationalAxisMemoizedSerializedSize); | ||
1898 | foreach (float element in rotationalAxis_) { | ||
1899 | output.WriteFloatNoTag(element); | ||
1900 | } | ||
1901 | } | ||
1902 | if (HasAngularSpeed) { | ||
1903 | output.WriteFloat(8, AngularSpeed); | ||
1904 | } | ||
1905 | UnknownFields.WriteTo(output); | ||
1906 | } | ||
1907 | |||
1908 | private int memoizedSerializedSize = -1; | ||
1909 | public override int SerializedSize { | ||
1910 | get { | ||
1911 | int size = memoizedSerializedSize; | ||
1912 | if (size != -1) return size; | ||
1913 | |||
1914 | size = 0; | ||
1915 | if (HasTimestamp) { | ||
1916 | size += pb::CodedOutputStream.ComputeFixed64Size(2, Timestamp); | ||
1917 | } | ||
1918 | { | ||
1919 | int dataSize = 0; | ||
1920 | dataSize = 8 * position_.Count; | ||
1921 | size += dataSize; | ||
1922 | if (position_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
1923 | positionMemoizedSerializedSize = dataSize; | ||
1924 | } | ||
1925 | { | ||
1926 | int dataSize = 0; | ||
1927 | dataSize = 4 * orientation_.Count; | ||
1928 | size += dataSize; | ||
1929 | if (orientation_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
1930 | orientationMemoizedSerializedSize = dataSize; | ||
1931 | } | ||
1932 | { | ||
1933 | int dataSize = 0; | ||
1934 | dataSize = 4 * velocity_.Count; | ||
1935 | size += dataSize; | ||
1936 | if (velocity_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
1937 | velocityMemoizedSerializedSize = dataSize; | ||
1938 | } | ||
1939 | { | ||
1940 | int dataSize = 0; | ||
1941 | dataSize = 4 * rotationalAxis_.Count; | ||
1942 | size += dataSize; | ||
1943 | if (rotationalAxis_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
1944 | rotationalAxisMemoizedSerializedSize = dataSize; | ||
1945 | } | ||
1946 | if (HasAngularSpeed) { | ||
1947 | size += pb::CodedOutputStream.ComputeFloatSize(8, AngularSpeed); | ||
1948 | } | ||
1949 | if (HasUpdateFlags) { | ||
1950 | size += pb::CodedOutputStream.ComputeUInt32Size(6, UpdateFlags); | ||
1951 | } | ||
1952 | size += UnknownFields.SerializedSize; | ||
1953 | memoizedSerializedSize = size; | ||
1954 | return size; | ||
1955 | } | ||
1956 | } | ||
1957 | |||
1958 | public static ObjLoc ParseFrom(pb::ByteString data) { | ||
1959 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1960 | } | ||
1961 | public static ObjLoc ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
1962 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1963 | } | ||
1964 | public static ObjLoc ParseFrom(byte[] data) { | ||
1965 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1966 | } | ||
1967 | public static ObjLoc ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
1968 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1969 | } | ||
1970 | public static ObjLoc ParseFrom(global::System.IO.Stream input) { | ||
1971 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1972 | } | ||
1973 | public static ObjLoc ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1974 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1975 | } | ||
1976 | public static ObjLoc ParseDelimitedFrom(global::System.IO.Stream input) { | ||
1977 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
1978 | } | ||
1979 | public static ObjLoc ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1980 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
1981 | } | ||
1982 | public static ObjLoc ParseFrom(pb::CodedInputStream input) { | ||
1983 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1984 | } | ||
1985 | public static ObjLoc ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1986 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1987 | } | ||
1988 | public static Builder CreateBuilder() { return new Builder(); } | ||
1989 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
1990 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
1991 | public static Builder CreateBuilder(ObjLoc prototype) { | ||
1992 | return (Builder) new Builder().MergeFrom(prototype); | ||
1993 | } | ||
1994 | |||
1995 | public sealed partial class Builder : pb::GeneratedBuilder<ObjLoc, Builder> { | ||
1996 | protected override Builder ThisBuilder { | ||
1997 | get { return this; } | ||
1998 | } | ||
1999 | public Builder() {} | ||
2000 | |||
2001 | ObjLoc result = new ObjLoc(); | ||
2002 | |||
2003 | protected override ObjLoc MessageBeingBuilt { | ||
2004 | get { return result; } | ||
2005 | } | ||
2006 | |||
2007 | public override Builder Clear() { | ||
2008 | result = new ObjLoc(); | ||
2009 | return this; | ||
2010 | } | ||
2011 | |||
2012 | public override Builder Clone() { | ||
2013 | return new Builder().MergeFrom(result); | ||
2014 | } | ||
2015 | |||
2016 | public override pbd::MessageDescriptor DescriptorForType { | ||
2017 | get { return global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Descriptor; } | ||
2018 | } | ||
2019 | |||
2020 | public override ObjLoc DefaultInstanceForType { | ||
2021 | get { return global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; } | ||
2022 | } | ||
2023 | |||
2024 | public override ObjLoc BuildPartial() { | ||
2025 | if (result == null) { | ||
2026 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
2027 | } | ||
2028 | result.position_.MakeReadOnly(); | ||
2029 | result.orientation_.MakeReadOnly(); | ||
2030 | result.velocity_.MakeReadOnly(); | ||
2031 | result.rotationalAxis_.MakeReadOnly(); | ||
2032 | ObjLoc returnMe = result; | ||
2033 | result = null; | ||
2034 | return returnMe; | ||
2035 | } | ||
2036 | |||
2037 | public override Builder MergeFrom(pb::IMessage other) { | ||
2038 | if (other is ObjLoc) { | ||
2039 | return MergeFrom((ObjLoc) other); | ||
2040 | } else { | ||
2041 | base.MergeFrom(other); | ||
2042 | return this; | ||
2043 | } | ||
2044 | } | ||
2045 | |||
2046 | public override Builder MergeFrom(ObjLoc other) { | ||
2047 | if (other == global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) return this; | ||
2048 | if (other.HasTimestamp) { | ||
2049 | Timestamp = other.Timestamp; | ||
2050 | } | ||
2051 | if (other.position_.Count != 0) { | ||
2052 | base.AddRange(other.position_, result.position_); | ||
2053 | } | ||
2054 | if (other.orientation_.Count != 0) { | ||
2055 | base.AddRange(other.orientation_, result.orientation_); | ||
2056 | } | ||
2057 | if (other.velocity_.Count != 0) { | ||
2058 | base.AddRange(other.velocity_, result.velocity_); | ||
2059 | } | ||
2060 | if (other.rotationalAxis_.Count != 0) { | ||
2061 | base.AddRange(other.rotationalAxis_, result.rotationalAxis_); | ||
2062 | } | ||
2063 | if (other.HasAngularSpeed) { | ||
2064 | AngularSpeed = other.AngularSpeed; | ||
2065 | } | ||
2066 | if (other.HasUpdateFlags) { | ||
2067 | UpdateFlags = other.UpdateFlags; | ||
2068 | } | ||
2069 | this.MergeUnknownFields(other.UnknownFields); | ||
2070 | return this; | ||
2071 | } | ||
2072 | |||
2073 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
2074 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
2075 | } | ||
2076 | |||
2077 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2078 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
2079 | while (true) { | ||
2080 | uint tag = input.ReadTag(); | ||
2081 | switch (tag) { | ||
2082 | case 0: { | ||
2083 | if (unknownFields != null) { | ||
2084 | this.UnknownFields = unknownFields.Build(); | ||
2085 | } | ||
2086 | return this; | ||
2087 | } | ||
2088 | default: { | ||
2089 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
2090 | if (unknownFields != null) { | ||
2091 | this.UnknownFields = unknownFields.Build(); | ||
2092 | } | ||
2093 | return this; | ||
2094 | } | ||
2095 | if (unknownFields == null) { | ||
2096 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2097 | } | ||
2098 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
2099 | break; | ||
2100 | } | ||
2101 | case 17: { | ||
2102 | Timestamp = input.ReadFixed64(); | ||
2103 | break; | ||
2104 | } | ||
2105 | case 26: { | ||
2106 | int length = input.ReadInt32(); | ||
2107 | int limit = input.PushLimit(length); | ||
2108 | while (!input.ReachedLimit) { | ||
2109 | AddPosition(input.ReadDouble()); | ||
2110 | } | ||
2111 | input.PopLimit(limit); | ||
2112 | break; | ||
2113 | } | ||
2114 | case 34: { | ||
2115 | int length = input.ReadInt32(); | ||
2116 | int limit = input.PushLimit(length); | ||
2117 | while (!input.ReachedLimit) { | ||
2118 | AddOrientation(input.ReadFloat()); | ||
2119 | } | ||
2120 | input.PopLimit(limit); | ||
2121 | break; | ||
2122 | } | ||
2123 | case 42: { | ||
2124 | int length = input.ReadInt32(); | ||
2125 | int limit = input.PushLimit(length); | ||
2126 | while (!input.ReachedLimit) { | ||
2127 | AddVelocity(input.ReadFloat()); | ||
2128 | } | ||
2129 | input.PopLimit(limit); | ||
2130 | break; | ||
2131 | } | ||
2132 | case 48: { | ||
2133 | UpdateFlags = input.ReadUInt32(); | ||
2134 | break; | ||
2135 | } | ||
2136 | case 58: { | ||
2137 | int length = input.ReadInt32(); | ||
2138 | int limit = input.PushLimit(length); | ||
2139 | while (!input.ReachedLimit) { | ||
2140 | AddRotationalAxis(input.ReadFloat()); | ||
2141 | } | ||
2142 | input.PopLimit(limit); | ||
2143 | break; | ||
2144 | } | ||
2145 | case 69: { | ||
2146 | AngularSpeed = input.ReadFloat(); | ||
2147 | break; | ||
2148 | } | ||
2149 | } | ||
2150 | } | ||
2151 | } | ||
2152 | |||
2153 | |||
2154 | public bool HasTimestamp { | ||
2155 | get { return result.HasTimestamp; } | ||
2156 | } | ||
2157 | [global::System.CLSCompliant(false)] | ||
2158 | public ulong Timestamp { | ||
2159 | get { return result.Timestamp; } | ||
2160 | set { SetTimestamp(value); } | ||
2161 | } | ||
2162 | [global::System.CLSCompliant(false)] | ||
2163 | public Builder SetTimestamp(ulong value) { | ||
2164 | result.hasTimestamp = true; | ||
2165 | result.timestamp_ = value; | ||
2166 | return this; | ||
2167 | } | ||
2168 | public Builder ClearTimestamp() { | ||
2169 | result.hasTimestamp = false; | ||
2170 | result.timestamp_ = 0; | ||
2171 | return this; | ||
2172 | } | ||
2173 | |||
2174 | public pbc::IPopsicleList<double> PositionList { | ||
2175 | get { return result.position_; } | ||
2176 | } | ||
2177 | public int PositionCount { | ||
2178 | get { return result.PositionCount; } | ||
2179 | } | ||
2180 | public double GetPosition(int index) { | ||
2181 | return result.GetPosition(index); | ||
2182 | } | ||
2183 | public Builder SetPosition(int index, double value) { | ||
2184 | result.position_[index] = value; | ||
2185 | return this; | ||
2186 | } | ||
2187 | public Builder AddPosition(double value) { | ||
2188 | result.position_.Add(value); | ||
2189 | return this; | ||
2190 | } | ||
2191 | public Builder AddRangePosition(scg::IEnumerable<double> values) { | ||
2192 | base.AddRange(values, result.position_); | ||
2193 | return this; | ||
2194 | } | ||
2195 | public Builder ClearPosition() { | ||
2196 | result.position_.Clear(); | ||
2197 | return this; | ||
2198 | } | ||
2199 | |||
2200 | public pbc::IPopsicleList<float> OrientationList { | ||
2201 | get { return result.orientation_; } | ||
2202 | } | ||
2203 | public int OrientationCount { | ||
2204 | get { return result.OrientationCount; } | ||
2205 | } | ||
2206 | public float GetOrientation(int index) { | ||
2207 | return result.GetOrientation(index); | ||
2208 | } | ||
2209 | public Builder SetOrientation(int index, float value) { | ||
2210 | result.orientation_[index] = value; | ||
2211 | return this; | ||
2212 | } | ||
2213 | public Builder AddOrientation(float value) { | ||
2214 | result.orientation_.Add(value); | ||
2215 | return this; | ||
2216 | } | ||
2217 | public Builder AddRangeOrientation(scg::IEnumerable<float> values) { | ||
2218 | base.AddRange(values, result.orientation_); | ||
2219 | return this; | ||
2220 | } | ||
2221 | public Builder ClearOrientation() { | ||
2222 | result.orientation_.Clear(); | ||
2223 | return this; | ||
2224 | } | ||
2225 | |||
2226 | public pbc::IPopsicleList<float> VelocityList { | ||
2227 | get { return result.velocity_; } | ||
2228 | } | ||
2229 | public int VelocityCount { | ||
2230 | get { return result.VelocityCount; } | ||
2231 | } | ||
2232 | public float GetVelocity(int index) { | ||
2233 | return result.GetVelocity(index); | ||
2234 | } | ||
2235 | public Builder SetVelocity(int index, float value) { | ||
2236 | result.velocity_[index] = value; | ||
2237 | return this; | ||
2238 | } | ||
2239 | public Builder AddVelocity(float value) { | ||
2240 | result.velocity_.Add(value); | ||
2241 | return this; | ||
2242 | } | ||
2243 | public Builder AddRangeVelocity(scg::IEnumerable<float> values) { | ||
2244 | base.AddRange(values, result.velocity_); | ||
2245 | return this; | ||
2246 | } | ||
2247 | public Builder ClearVelocity() { | ||
2248 | result.velocity_.Clear(); | ||
2249 | return this; | ||
2250 | } | ||
2251 | |||
2252 | public pbc::IPopsicleList<float> RotationalAxisList { | ||
2253 | get { return result.rotationalAxis_; } | ||
2254 | } | ||
2255 | public int RotationalAxisCount { | ||
2256 | get { return result.RotationalAxisCount; } | ||
2257 | } | ||
2258 | public float GetRotationalAxis(int index) { | ||
2259 | return result.GetRotationalAxis(index); | ||
2260 | } | ||
2261 | public Builder SetRotationalAxis(int index, float value) { | ||
2262 | result.rotationalAxis_[index] = value; | ||
2263 | return this; | ||
2264 | } | ||
2265 | public Builder AddRotationalAxis(float value) { | ||
2266 | result.rotationalAxis_.Add(value); | ||
2267 | return this; | ||
2268 | } | ||
2269 | public Builder AddRangeRotationalAxis(scg::IEnumerable<float> values) { | ||
2270 | base.AddRange(values, result.rotationalAxis_); | ||
2271 | return this; | ||
2272 | } | ||
2273 | public Builder ClearRotationalAxis() { | ||
2274 | result.rotationalAxis_.Clear(); | ||
2275 | return this; | ||
2276 | } | ||
2277 | |||
2278 | public bool HasAngularSpeed { | ||
2279 | get { return result.HasAngularSpeed; } | ||
2280 | } | ||
2281 | public float AngularSpeed { | ||
2282 | get { return result.AngularSpeed; } | ||
2283 | set { SetAngularSpeed(value); } | ||
2284 | } | ||
2285 | public Builder SetAngularSpeed(float value) { | ||
2286 | result.hasAngularSpeed = true; | ||
2287 | result.angularSpeed_ = value; | ||
2288 | return this; | ||
2289 | } | ||
2290 | public Builder ClearAngularSpeed() { | ||
2291 | result.hasAngularSpeed = false; | ||
2292 | result.angularSpeed_ = 0F; | ||
2293 | return this; | ||
2294 | } | ||
2295 | |||
2296 | public bool HasUpdateFlags { | ||
2297 | get { return result.HasUpdateFlags; } | ||
2298 | } | ||
2299 | [global::System.CLSCompliant(false)] | ||
2300 | public uint UpdateFlags { | ||
2301 | get { return result.UpdateFlags; } | ||
2302 | set { SetUpdateFlags(value); } | ||
2303 | } | ||
2304 | [global::System.CLSCompliant(false)] | ||
2305 | public Builder SetUpdateFlags(uint value) { | ||
2306 | result.hasUpdateFlags = true; | ||
2307 | result.updateFlags_ = value; | ||
2308 | return this; | ||
2309 | } | ||
2310 | public Builder ClearUpdateFlags() { | ||
2311 | result.hasUpdateFlags = false; | ||
2312 | result.updateFlags_ = 0; | ||
2313 | return this; | ||
2314 | } | ||
2315 | } | ||
2316 | static ObjLoc() { | ||
2317 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
2318 | } | ||
2319 | } | ||
2320 | |||
2321 | public sealed partial class LocRequest : pb::GeneratedMessage<LocRequest, LocRequest.Builder> { | ||
2322 | private static readonly LocRequest defaultInstance = new Builder().BuildPartial(); | ||
2323 | public static LocRequest DefaultInstance { | ||
2324 | get { return defaultInstance; } | ||
2325 | } | ||
2326 | |||
2327 | public override LocRequest DefaultInstanceForType { | ||
2328 | get { return defaultInstance; } | ||
2329 | } | ||
2330 | |||
2331 | protected override LocRequest ThisMessage { | ||
2332 | get { return this; } | ||
2333 | } | ||
2334 | |||
2335 | public static pbd::MessageDescriptor Descriptor { | ||
2336 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__Descriptor; } | ||
2337 | } | ||
2338 | |||
2339 | protected override pb::FieldAccess.FieldAccessorTable<LocRequest, LocRequest.Builder> InternalFieldAccessors { | ||
2340 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LocRequest__FieldAccessorTable; } | ||
2341 | } | ||
2342 | |||
2343 | #region Nested types | ||
2344 | public static class Types { | ||
2345 | public enum Fields { | ||
2346 | POSITION = 1, | ||
2347 | ORIENTATION = 2, | ||
2348 | VELOCITY = 4, | ||
2349 | ROTATIONAL_AXIS = 8, | ||
2350 | ANGULAR_SPEED = 16, | ||
2351 | } | ||
2352 | |||
2353 | } | ||
2354 | #endregion | ||
2355 | |||
2356 | public const int RequestedFieldsFieldNumber = 2; | ||
2357 | private bool hasRequestedFields; | ||
2358 | private uint requestedFields_ = 0; | ||
2359 | public bool HasRequestedFields { | ||
2360 | get { return hasRequestedFields; } | ||
2361 | } | ||
2362 | [global::System.CLSCompliant(false)] | ||
2363 | public uint RequestedFields { | ||
2364 | get { return requestedFields_; } | ||
2365 | } | ||
2366 | |||
2367 | public override bool IsInitialized { | ||
2368 | get { | ||
2369 | return true; | ||
2370 | } | ||
2371 | } | ||
2372 | |||
2373 | public override void WriteTo(pb::CodedOutputStream output) { | ||
2374 | if (HasRequestedFields) { | ||
2375 | output.WriteUInt32(2, RequestedFields); | ||
2376 | } | ||
2377 | UnknownFields.WriteTo(output); | ||
2378 | } | ||
2379 | |||
2380 | private int memoizedSerializedSize = -1; | ||
2381 | public override int SerializedSize { | ||
2382 | get { | ||
2383 | int size = memoizedSerializedSize; | ||
2384 | if (size != -1) return size; | ||
2385 | |||
2386 | size = 0; | ||
2387 | if (HasRequestedFields) { | ||
2388 | size += pb::CodedOutputStream.ComputeUInt32Size(2, RequestedFields); | ||
2389 | } | ||
2390 | size += UnknownFields.SerializedSize; | ||
2391 | memoizedSerializedSize = size; | ||
2392 | return size; | ||
2393 | } | ||
2394 | } | ||
2395 | |||
2396 | public static LocRequest ParseFrom(pb::ByteString data) { | ||
2397 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2398 | } | ||
2399 | public static LocRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
2400 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2401 | } | ||
2402 | public static LocRequest ParseFrom(byte[] data) { | ||
2403 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2404 | } | ||
2405 | public static LocRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
2406 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2407 | } | ||
2408 | public static LocRequest ParseFrom(global::System.IO.Stream input) { | ||
2409 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2410 | } | ||
2411 | public static LocRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2412 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2413 | } | ||
2414 | public static LocRequest ParseDelimitedFrom(global::System.IO.Stream input) { | ||
2415 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
2416 | } | ||
2417 | public static LocRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2418 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
2419 | } | ||
2420 | public static LocRequest ParseFrom(pb::CodedInputStream input) { | ||
2421 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2422 | } | ||
2423 | public static LocRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2424 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2425 | } | ||
2426 | public static Builder CreateBuilder() { return new Builder(); } | ||
2427 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
2428 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
2429 | public static Builder CreateBuilder(LocRequest prototype) { | ||
2430 | return (Builder) new Builder().MergeFrom(prototype); | ||
2431 | } | ||
2432 | |||
2433 | public sealed partial class Builder : pb::GeneratedBuilder<LocRequest, Builder> { | ||
2434 | protected override Builder ThisBuilder { | ||
2435 | get { return this; } | ||
2436 | } | ||
2437 | public Builder() {} | ||
2438 | |||
2439 | LocRequest result = new LocRequest(); | ||
2440 | |||
2441 | protected override LocRequest MessageBeingBuilt { | ||
2442 | get { return result; } | ||
2443 | } | ||
2444 | |||
2445 | public override Builder Clear() { | ||
2446 | result = new LocRequest(); | ||
2447 | return this; | ||
2448 | } | ||
2449 | |||
2450 | public override Builder Clone() { | ||
2451 | return new Builder().MergeFrom(result); | ||
2452 | } | ||
2453 | |||
2454 | public override pbd::MessageDescriptor DescriptorForType { | ||
2455 | get { return global::Sirikata.Protocol._PBJ_Internal.LocRequest.Descriptor; } | ||
2456 | } | ||
2457 | |||
2458 | public override LocRequest DefaultInstanceForType { | ||
2459 | get { return global::Sirikata.Protocol._PBJ_Internal.LocRequest.DefaultInstance; } | ||
2460 | } | ||
2461 | |||
2462 | public override LocRequest BuildPartial() { | ||
2463 | if (result == null) { | ||
2464 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
2465 | } | ||
2466 | LocRequest returnMe = result; | ||
2467 | result = null; | ||
2468 | return returnMe; | ||
2469 | } | ||
2470 | |||
2471 | public override Builder MergeFrom(pb::IMessage other) { | ||
2472 | if (other is LocRequest) { | ||
2473 | return MergeFrom((LocRequest) other); | ||
2474 | } else { | ||
2475 | base.MergeFrom(other); | ||
2476 | return this; | ||
2477 | } | ||
2478 | } | ||
2479 | |||
2480 | public override Builder MergeFrom(LocRequest other) { | ||
2481 | if (other == global::Sirikata.Protocol._PBJ_Internal.LocRequest.DefaultInstance) return this; | ||
2482 | if (other.HasRequestedFields) { | ||
2483 | RequestedFields = other.RequestedFields; | ||
2484 | } | ||
2485 | this.MergeUnknownFields(other.UnknownFields); | ||
2486 | return this; | ||
2487 | } | ||
2488 | |||
2489 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
2490 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
2491 | } | ||
2492 | |||
2493 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2494 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
2495 | while (true) { | ||
2496 | uint tag = input.ReadTag(); | ||
2497 | switch (tag) { | ||
2498 | case 0: { | ||
2499 | if (unknownFields != null) { | ||
2500 | this.UnknownFields = unknownFields.Build(); | ||
2501 | } | ||
2502 | return this; | ||
2503 | } | ||
2504 | default: { | ||
2505 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
2506 | if (unknownFields != null) { | ||
2507 | this.UnknownFields = unknownFields.Build(); | ||
2508 | } | ||
2509 | return this; | ||
2510 | } | ||
2511 | if (unknownFields == null) { | ||
2512 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2513 | } | ||
2514 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
2515 | break; | ||
2516 | } | ||
2517 | case 16: { | ||
2518 | RequestedFields = input.ReadUInt32(); | ||
2519 | break; | ||
2520 | } | ||
2521 | } | ||
2522 | } | ||
2523 | } | ||
2524 | |||
2525 | |||
2526 | public bool HasRequestedFields { | ||
2527 | get { return result.HasRequestedFields; } | ||
2528 | } | ||
2529 | [global::System.CLSCompliant(false)] | ||
2530 | public uint RequestedFields { | ||
2531 | get { return result.RequestedFields; } | ||
2532 | set { SetRequestedFields(value); } | ||
2533 | } | ||
2534 | [global::System.CLSCompliant(false)] | ||
2535 | public Builder SetRequestedFields(uint value) { | ||
2536 | result.hasRequestedFields = true; | ||
2537 | result.requestedFields_ = value; | ||
2538 | return this; | ||
2539 | } | ||
2540 | public Builder ClearRequestedFields() { | ||
2541 | result.hasRequestedFields = false; | ||
2542 | result.requestedFields_ = 0; | ||
2543 | return this; | ||
2544 | } | ||
2545 | } | ||
2546 | static LocRequest() { | ||
2547 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
2548 | } | ||
2549 | } | ||
2550 | |||
2551 | public sealed partial class NewObj : pb::GeneratedMessage<NewObj, NewObj.Builder> { | ||
2552 | private static readonly NewObj defaultInstance = new Builder().BuildPartial(); | ||
2553 | public static NewObj DefaultInstance { | ||
2554 | get { return defaultInstance; } | ||
2555 | } | ||
2556 | |||
2557 | public override NewObj DefaultInstanceForType { | ||
2558 | get { return defaultInstance; } | ||
2559 | } | ||
2560 | |||
2561 | protected override NewObj ThisMessage { | ||
2562 | get { return this; } | ||
2563 | } | ||
2564 | |||
2565 | public static pbd::MessageDescriptor Descriptor { | ||
2566 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__Descriptor; } | ||
2567 | } | ||
2568 | |||
2569 | protected override pb::FieldAccess.FieldAccessorTable<NewObj, NewObj.Builder> InternalFieldAccessors { | ||
2570 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewObj__FieldAccessorTable; } | ||
2571 | } | ||
2572 | |||
2573 | public const int ObjectUuidEvidenceFieldNumber = 2; | ||
2574 | private bool hasObjectUuidEvidence; | ||
2575 | private pb::ByteString objectUuidEvidence_ = pb::ByteString.Empty; | ||
2576 | public bool HasObjectUuidEvidence { | ||
2577 | get { return hasObjectUuidEvidence; } | ||
2578 | } | ||
2579 | public pb::ByteString ObjectUuidEvidence { | ||
2580 | get { return objectUuidEvidence_; } | ||
2581 | } | ||
2582 | |||
2583 | public const int RequestedObjectLocFieldNumber = 3; | ||
2584 | private bool hasRequestedObjectLoc; | ||
2585 | private global::Sirikata.Protocol._PBJ_Internal.ObjLoc requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; | ||
2586 | public bool HasRequestedObjectLoc { | ||
2587 | get { return hasRequestedObjectLoc; } | ||
2588 | } | ||
2589 | public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { | ||
2590 | get { return requestedObjectLoc_; } | ||
2591 | } | ||
2592 | |||
2593 | public const int BoundingSphereFieldNumber = 4; | ||
2594 | private int boundingSphereMemoizedSerializedSize; | ||
2595 | private pbc::PopsicleList<float> boundingSphere_ = new pbc::PopsicleList<float>(); | ||
2596 | public scg::IList<float> BoundingSphereList { | ||
2597 | get { return pbc::Lists.AsReadOnly(boundingSphere_); } | ||
2598 | } | ||
2599 | public int BoundingSphereCount { | ||
2600 | get { return boundingSphere_.Count; } | ||
2601 | } | ||
2602 | public float GetBoundingSphere(int index) { | ||
2603 | return boundingSphere_[index]; | ||
2604 | } | ||
2605 | |||
2606 | public override bool IsInitialized { | ||
2607 | get { | ||
2608 | return true; | ||
2609 | } | ||
2610 | } | ||
2611 | |||
2612 | public override void WriteTo(pb::CodedOutputStream output) { | ||
2613 | if (HasObjectUuidEvidence) { | ||
2614 | output.WriteBytes(2, ObjectUuidEvidence); | ||
2615 | } | ||
2616 | if (HasRequestedObjectLoc) { | ||
2617 | output.WriteMessage(3, RequestedObjectLoc); | ||
2618 | } | ||
2619 | if (boundingSphere_.Count > 0) { | ||
2620 | output.WriteRawVarint32(34); | ||
2621 | output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); | ||
2622 | foreach (float element in boundingSphere_) { | ||
2623 | output.WriteFloatNoTag(element); | ||
2624 | } | ||
2625 | } | ||
2626 | UnknownFields.WriteTo(output); | ||
2627 | } | ||
2628 | |||
2629 | private int memoizedSerializedSize = -1; | ||
2630 | public override int SerializedSize { | ||
2631 | get { | ||
2632 | int size = memoizedSerializedSize; | ||
2633 | if (size != -1) return size; | ||
2634 | |||
2635 | size = 0; | ||
2636 | if (HasObjectUuidEvidence) { | ||
2637 | size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectUuidEvidence); | ||
2638 | } | ||
2639 | if (HasRequestedObjectLoc) { | ||
2640 | size += pb::CodedOutputStream.ComputeMessageSize(3, RequestedObjectLoc); | ||
2641 | } | ||
2642 | { | ||
2643 | int dataSize = 0; | ||
2644 | dataSize = 4 * boundingSphere_.Count; | ||
2645 | size += dataSize; | ||
2646 | if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2647 | boundingSphereMemoizedSerializedSize = dataSize; | ||
2648 | } | ||
2649 | size += UnknownFields.SerializedSize; | ||
2650 | memoizedSerializedSize = size; | ||
2651 | return size; | ||
2652 | } | ||
2653 | } | ||
2654 | |||
2655 | public static NewObj ParseFrom(pb::ByteString data) { | ||
2656 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2657 | } | ||
2658 | public static NewObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
2659 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2660 | } | ||
2661 | public static NewObj ParseFrom(byte[] data) { | ||
2662 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2663 | } | ||
2664 | public static NewObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
2665 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2666 | } | ||
2667 | public static NewObj ParseFrom(global::System.IO.Stream input) { | ||
2668 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2669 | } | ||
2670 | public static NewObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2671 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2672 | } | ||
2673 | public static NewObj ParseDelimitedFrom(global::System.IO.Stream input) { | ||
2674 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
2675 | } | ||
2676 | public static NewObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2677 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
2678 | } | ||
2679 | public static NewObj ParseFrom(pb::CodedInputStream input) { | ||
2680 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2681 | } | ||
2682 | public static NewObj ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2683 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2684 | } | ||
2685 | public static Builder CreateBuilder() { return new Builder(); } | ||
2686 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
2687 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
2688 | public static Builder CreateBuilder(NewObj prototype) { | ||
2689 | return (Builder) new Builder().MergeFrom(prototype); | ||
2690 | } | ||
2691 | |||
2692 | public sealed partial class Builder : pb::GeneratedBuilder<NewObj, Builder> { | ||
2693 | protected override Builder ThisBuilder { | ||
2694 | get { return this; } | ||
2695 | } | ||
2696 | public Builder() {} | ||
2697 | |||
2698 | NewObj result = new NewObj(); | ||
2699 | |||
2700 | protected override NewObj MessageBeingBuilt { | ||
2701 | get { return result; } | ||
2702 | } | ||
2703 | |||
2704 | public override Builder Clear() { | ||
2705 | result = new NewObj(); | ||
2706 | return this; | ||
2707 | } | ||
2708 | |||
2709 | public override Builder Clone() { | ||
2710 | return new Builder().MergeFrom(result); | ||
2711 | } | ||
2712 | |||
2713 | public override pbd::MessageDescriptor DescriptorForType { | ||
2714 | get { return global::Sirikata.Protocol._PBJ_Internal.NewObj.Descriptor; } | ||
2715 | } | ||
2716 | |||
2717 | public override NewObj DefaultInstanceForType { | ||
2718 | get { return global::Sirikata.Protocol._PBJ_Internal.NewObj.DefaultInstance; } | ||
2719 | } | ||
2720 | |||
2721 | public override NewObj BuildPartial() { | ||
2722 | if (result == null) { | ||
2723 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
2724 | } | ||
2725 | result.boundingSphere_.MakeReadOnly(); | ||
2726 | NewObj returnMe = result; | ||
2727 | result = null; | ||
2728 | return returnMe; | ||
2729 | } | ||
2730 | |||
2731 | public override Builder MergeFrom(pb::IMessage other) { | ||
2732 | if (other is NewObj) { | ||
2733 | return MergeFrom((NewObj) other); | ||
2734 | } else { | ||
2735 | base.MergeFrom(other); | ||
2736 | return this; | ||
2737 | } | ||
2738 | } | ||
2739 | |||
2740 | public override Builder MergeFrom(NewObj other) { | ||
2741 | if (other == global::Sirikata.Protocol._PBJ_Internal.NewObj.DefaultInstance) return this; | ||
2742 | if (other.HasObjectUuidEvidence) { | ||
2743 | ObjectUuidEvidence = other.ObjectUuidEvidence; | ||
2744 | } | ||
2745 | if (other.HasRequestedObjectLoc) { | ||
2746 | MergeRequestedObjectLoc(other.RequestedObjectLoc); | ||
2747 | } | ||
2748 | if (other.boundingSphere_.Count != 0) { | ||
2749 | base.AddRange(other.boundingSphere_, result.boundingSphere_); | ||
2750 | } | ||
2751 | this.MergeUnknownFields(other.UnknownFields); | ||
2752 | return this; | ||
2753 | } | ||
2754 | |||
2755 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
2756 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
2757 | } | ||
2758 | |||
2759 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2760 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
2761 | while (true) { | ||
2762 | uint tag = input.ReadTag(); | ||
2763 | switch (tag) { | ||
2764 | case 0: { | ||
2765 | if (unknownFields != null) { | ||
2766 | this.UnknownFields = unknownFields.Build(); | ||
2767 | } | ||
2768 | return this; | ||
2769 | } | ||
2770 | default: { | ||
2771 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
2772 | if (unknownFields != null) { | ||
2773 | this.UnknownFields = unknownFields.Build(); | ||
2774 | } | ||
2775 | return this; | ||
2776 | } | ||
2777 | if (unknownFields == null) { | ||
2778 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2779 | } | ||
2780 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
2781 | break; | ||
2782 | } | ||
2783 | case 18: { | ||
2784 | ObjectUuidEvidence = input.ReadBytes(); | ||
2785 | break; | ||
2786 | } | ||
2787 | case 26: { | ||
2788 | global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); | ||
2789 | if (HasRequestedObjectLoc) { | ||
2790 | subBuilder.MergeFrom(RequestedObjectLoc); | ||
2791 | } | ||
2792 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2793 | RequestedObjectLoc = subBuilder.BuildPartial(); | ||
2794 | break; | ||
2795 | } | ||
2796 | case 34: { | ||
2797 | int length = input.ReadInt32(); | ||
2798 | int limit = input.PushLimit(length); | ||
2799 | while (!input.ReachedLimit) { | ||
2800 | AddBoundingSphere(input.ReadFloat()); | ||
2801 | } | ||
2802 | input.PopLimit(limit); | ||
2803 | break; | ||
2804 | } | ||
2805 | } | ||
2806 | } | ||
2807 | } | ||
2808 | |||
2809 | |||
2810 | public bool HasObjectUuidEvidence { | ||
2811 | get { return result.HasObjectUuidEvidence; } | ||
2812 | } | ||
2813 | public pb::ByteString ObjectUuidEvidence { | ||
2814 | get { return result.ObjectUuidEvidence; } | ||
2815 | set { SetObjectUuidEvidence(value); } | ||
2816 | } | ||
2817 | public Builder SetObjectUuidEvidence(pb::ByteString value) { | ||
2818 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2819 | result.hasObjectUuidEvidence = true; | ||
2820 | result.objectUuidEvidence_ = value; | ||
2821 | return this; | ||
2822 | } | ||
2823 | public Builder ClearObjectUuidEvidence() { | ||
2824 | result.hasObjectUuidEvidence = false; | ||
2825 | result.objectUuidEvidence_ = pb::ByteString.Empty; | ||
2826 | return this; | ||
2827 | } | ||
2828 | |||
2829 | public bool HasRequestedObjectLoc { | ||
2830 | get { return result.HasRequestedObjectLoc; } | ||
2831 | } | ||
2832 | public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { | ||
2833 | get { return result.RequestedObjectLoc; } | ||
2834 | set { SetRequestedObjectLoc(value); } | ||
2835 | } | ||
2836 | public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { | ||
2837 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2838 | result.hasRequestedObjectLoc = true; | ||
2839 | result.requestedObjectLoc_ = value; | ||
2840 | return this; | ||
2841 | } | ||
2842 | public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { | ||
2843 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
2844 | result.hasRequestedObjectLoc = true; | ||
2845 | result.requestedObjectLoc_ = builderForValue.Build(); | ||
2846 | return this; | ||
2847 | } | ||
2848 | public Builder MergeRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { | ||
2849 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2850 | if (result.HasRequestedObjectLoc && | ||
2851 | result.requestedObjectLoc_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { | ||
2852 | result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.requestedObjectLoc_).MergeFrom(value).BuildPartial(); | ||
2853 | } else { | ||
2854 | result.requestedObjectLoc_ = value; | ||
2855 | } | ||
2856 | result.hasRequestedObjectLoc = true; | ||
2857 | return this; | ||
2858 | } | ||
2859 | public Builder ClearRequestedObjectLoc() { | ||
2860 | result.hasRequestedObjectLoc = false; | ||
2861 | result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; | ||
2862 | return this; | ||
2863 | } | ||
2864 | |||
2865 | public pbc::IPopsicleList<float> BoundingSphereList { | ||
2866 | get { return result.boundingSphere_; } | ||
2867 | } | ||
2868 | public int BoundingSphereCount { | ||
2869 | get { return result.BoundingSphereCount; } | ||
2870 | } | ||
2871 | public float GetBoundingSphere(int index) { | ||
2872 | return result.GetBoundingSphere(index); | ||
2873 | } | ||
2874 | public Builder SetBoundingSphere(int index, float value) { | ||
2875 | result.boundingSphere_[index] = value; | ||
2876 | return this; | ||
2877 | } | ||
2878 | public Builder AddBoundingSphere(float value) { | ||
2879 | result.boundingSphere_.Add(value); | ||
2880 | return this; | ||
2881 | } | ||
2882 | public Builder AddRangeBoundingSphere(scg::IEnumerable<float> values) { | ||
2883 | base.AddRange(values, result.boundingSphere_); | ||
2884 | return this; | ||
2885 | } | ||
2886 | public Builder ClearBoundingSphere() { | ||
2887 | result.boundingSphere_.Clear(); | ||
2888 | return this; | ||
2889 | } | ||
2890 | } | ||
2891 | static NewObj() { | ||
2892 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
2893 | } | ||
2894 | } | ||
2895 | |||
2896 | public sealed partial class RetObj : pb::GeneratedMessage<RetObj, RetObj.Builder> { | ||
2897 | private static readonly RetObj defaultInstance = new Builder().BuildPartial(); | ||
2898 | public static RetObj DefaultInstance { | ||
2899 | get { return defaultInstance; } | ||
2900 | } | ||
2901 | |||
2902 | public override RetObj DefaultInstanceForType { | ||
2903 | get { return defaultInstance; } | ||
2904 | } | ||
2905 | |||
2906 | protected override RetObj ThisMessage { | ||
2907 | get { return this; } | ||
2908 | } | ||
2909 | |||
2910 | public static pbd::MessageDescriptor Descriptor { | ||
2911 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__Descriptor; } | ||
2912 | } | ||
2913 | |||
2914 | protected override pb::FieldAccess.FieldAccessorTable<RetObj, RetObj.Builder> InternalFieldAccessors { | ||
2915 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_RetObj__FieldAccessorTable; } | ||
2916 | } | ||
2917 | |||
2918 | public const int ObjectReferenceFieldNumber = 2; | ||
2919 | private bool hasObjectReference; | ||
2920 | private pb::ByteString objectReference_ = pb::ByteString.Empty; | ||
2921 | public bool HasObjectReference { | ||
2922 | get { return hasObjectReference; } | ||
2923 | } | ||
2924 | public pb::ByteString ObjectReference { | ||
2925 | get { return objectReference_; } | ||
2926 | } | ||
2927 | |||
2928 | public const int LocationFieldNumber = 3; | ||
2929 | private bool hasLocation; | ||
2930 | private global::Sirikata.Protocol._PBJ_Internal.ObjLoc location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; | ||
2931 | public bool HasLocation { | ||
2932 | get { return hasLocation; } | ||
2933 | } | ||
2934 | public global::Sirikata.Protocol._PBJ_Internal.ObjLoc Location { | ||
2935 | get { return location_; } | ||
2936 | } | ||
2937 | |||
2938 | public const int BoundingSphereFieldNumber = 4; | ||
2939 | private int boundingSphereMemoizedSerializedSize; | ||
2940 | private pbc::PopsicleList<float> boundingSphere_ = new pbc::PopsicleList<float>(); | ||
2941 | public scg::IList<float> BoundingSphereList { | ||
2942 | get { return pbc::Lists.AsReadOnly(boundingSphere_); } | ||
2943 | } | ||
2944 | public int BoundingSphereCount { | ||
2945 | get { return boundingSphere_.Count; } | ||
2946 | } | ||
2947 | public float GetBoundingSphere(int index) { | ||
2948 | return boundingSphere_[index]; | ||
2949 | } | ||
2950 | |||
2951 | public override bool IsInitialized { | ||
2952 | get { | ||
2953 | return true; | ||
2954 | } | ||
2955 | } | ||
2956 | |||
2957 | public override void WriteTo(pb::CodedOutputStream output) { | ||
2958 | if (HasObjectReference) { | ||
2959 | output.WriteBytes(2, ObjectReference); | ||
2960 | } | ||
2961 | if (HasLocation) { | ||
2962 | output.WriteMessage(3, Location); | ||
2963 | } | ||
2964 | if (boundingSphere_.Count > 0) { | ||
2965 | output.WriteRawVarint32(34); | ||
2966 | output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); | ||
2967 | foreach (float element in boundingSphere_) { | ||
2968 | output.WriteFloatNoTag(element); | ||
2969 | } | ||
2970 | } | ||
2971 | UnknownFields.WriteTo(output); | ||
2972 | } | ||
2973 | |||
2974 | private int memoizedSerializedSize = -1; | ||
2975 | public override int SerializedSize { | ||
2976 | get { | ||
2977 | int size = memoizedSerializedSize; | ||
2978 | if (size != -1) return size; | ||
2979 | |||
2980 | size = 0; | ||
2981 | if (HasObjectReference) { | ||
2982 | size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectReference); | ||
2983 | } | ||
2984 | if (HasLocation) { | ||
2985 | size += pb::CodedOutputStream.ComputeMessageSize(3, Location); | ||
2986 | } | ||
2987 | { | ||
2988 | int dataSize = 0; | ||
2989 | dataSize = 4 * boundingSphere_.Count; | ||
2990 | size += dataSize; | ||
2991 | if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2992 | boundingSphereMemoizedSerializedSize = dataSize; | ||
2993 | } | ||
2994 | size += UnknownFields.SerializedSize; | ||
2995 | memoizedSerializedSize = size; | ||
2996 | return size; | ||
2997 | } | ||
2998 | } | ||
2999 | |||
3000 | public static RetObj ParseFrom(pb::ByteString data) { | ||
3001 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3002 | } | ||
3003 | public static RetObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
3004 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3005 | } | ||
3006 | public static RetObj ParseFrom(byte[] data) { | ||
3007 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3008 | } | ||
3009 | public static RetObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
3010 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3011 | } | ||
3012 | public static RetObj ParseFrom(global::System.IO.Stream input) { | ||
3013 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3014 | } | ||
3015 | public static RetObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3016 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3017 | } | ||
3018 | public static RetObj ParseDelimitedFrom(global::System.IO.Stream input) { | ||
3019 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
3020 | } | ||
3021 | public static RetObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3022 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
3023 | } | ||
3024 | public static RetObj ParseFrom(pb::CodedInputStream input) { | ||
3025 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3026 | } | ||
3027 | public static RetObj ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3028 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3029 | } | ||
3030 | public static Builder CreateBuilder() { return new Builder(); } | ||
3031 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
3032 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
3033 | public static Builder CreateBuilder(RetObj prototype) { | ||
3034 | return (Builder) new Builder().MergeFrom(prototype); | ||
3035 | } | ||
3036 | |||
3037 | public sealed partial class Builder : pb::GeneratedBuilder<RetObj, Builder> { | ||
3038 | protected override Builder ThisBuilder { | ||
3039 | get { return this; } | ||
3040 | } | ||
3041 | public Builder() {} | ||
3042 | |||
3043 | RetObj result = new RetObj(); | ||
3044 | |||
3045 | protected override RetObj MessageBeingBuilt { | ||
3046 | get { return result; } | ||
3047 | } | ||
3048 | |||
3049 | public override Builder Clear() { | ||
3050 | result = new RetObj(); | ||
3051 | return this; | ||
3052 | } | ||
3053 | |||
3054 | public override Builder Clone() { | ||
3055 | return new Builder().MergeFrom(result); | ||
3056 | } | ||
3057 | |||
3058 | public override pbd::MessageDescriptor DescriptorForType { | ||
3059 | get { return global::Sirikata.Protocol._PBJ_Internal.RetObj.Descriptor; } | ||
3060 | } | ||
3061 | |||
3062 | public override RetObj DefaultInstanceForType { | ||
3063 | get { return global::Sirikata.Protocol._PBJ_Internal.RetObj.DefaultInstance; } | ||
3064 | } | ||
3065 | |||
3066 | public override RetObj BuildPartial() { | ||
3067 | if (result == null) { | ||
3068 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
3069 | } | ||
3070 | result.boundingSphere_.MakeReadOnly(); | ||
3071 | RetObj returnMe = result; | ||
3072 | result = null; | ||
3073 | return returnMe; | ||
3074 | } | ||
3075 | |||
3076 | public override Builder MergeFrom(pb::IMessage other) { | ||
3077 | if (other is RetObj) { | ||
3078 | return MergeFrom((RetObj) other); | ||
3079 | } else { | ||
3080 | base.MergeFrom(other); | ||
3081 | return this; | ||
3082 | } | ||
3083 | } | ||
3084 | |||
3085 | public override Builder MergeFrom(RetObj other) { | ||
3086 | if (other == global::Sirikata.Protocol._PBJ_Internal.RetObj.DefaultInstance) return this; | ||
3087 | if (other.HasObjectReference) { | ||
3088 | ObjectReference = other.ObjectReference; | ||
3089 | } | ||
3090 | if (other.HasLocation) { | ||
3091 | MergeLocation(other.Location); | ||
3092 | } | ||
3093 | if (other.boundingSphere_.Count != 0) { | ||
3094 | base.AddRange(other.boundingSphere_, result.boundingSphere_); | ||
3095 | } | ||
3096 | this.MergeUnknownFields(other.UnknownFields); | ||
3097 | return this; | ||
3098 | } | ||
3099 | |||
3100 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
3101 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
3102 | } | ||
3103 | |||
3104 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3105 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
3106 | while (true) { | ||
3107 | uint tag = input.ReadTag(); | ||
3108 | switch (tag) { | ||
3109 | case 0: { | ||
3110 | if (unknownFields != null) { | ||
3111 | this.UnknownFields = unknownFields.Build(); | ||
3112 | } | ||
3113 | return this; | ||
3114 | } | ||
3115 | default: { | ||
3116 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
3117 | if (unknownFields != null) { | ||
3118 | this.UnknownFields = unknownFields.Build(); | ||
3119 | } | ||
3120 | return this; | ||
3121 | } | ||
3122 | if (unknownFields == null) { | ||
3123 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
3124 | } | ||
3125 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
3126 | break; | ||
3127 | } | ||
3128 | case 18: { | ||
3129 | ObjectReference = input.ReadBytes(); | ||
3130 | break; | ||
3131 | } | ||
3132 | case 26: { | ||
3133 | global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); | ||
3134 | if (HasLocation) { | ||
3135 | subBuilder.MergeFrom(Location); | ||
3136 | } | ||
3137 | input.ReadMessage(subBuilder, extensionRegistry); | ||
3138 | Location = subBuilder.BuildPartial(); | ||
3139 | break; | ||
3140 | } | ||
3141 | case 34: { | ||
3142 | int length = input.ReadInt32(); | ||
3143 | int limit = input.PushLimit(length); | ||
3144 | while (!input.ReachedLimit) { | ||
3145 | AddBoundingSphere(input.ReadFloat()); | ||
3146 | } | ||
3147 | input.PopLimit(limit); | ||
3148 | break; | ||
3149 | } | ||
3150 | } | ||
3151 | } | ||
3152 | } | ||
3153 | |||
3154 | |||
3155 | public bool HasObjectReference { | ||
3156 | get { return result.HasObjectReference; } | ||
3157 | } | ||
3158 | public pb::ByteString ObjectReference { | ||
3159 | get { return result.ObjectReference; } | ||
3160 | set { SetObjectReference(value); } | ||
3161 | } | ||
3162 | public Builder SetObjectReference(pb::ByteString value) { | ||
3163 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3164 | result.hasObjectReference = true; | ||
3165 | result.objectReference_ = value; | ||
3166 | return this; | ||
3167 | } | ||
3168 | public Builder ClearObjectReference() { | ||
3169 | result.hasObjectReference = false; | ||
3170 | result.objectReference_ = pb::ByteString.Empty; | ||
3171 | return this; | ||
3172 | } | ||
3173 | |||
3174 | public bool HasLocation { | ||
3175 | get { return result.HasLocation; } | ||
3176 | } | ||
3177 | public global::Sirikata.Protocol._PBJ_Internal.ObjLoc Location { | ||
3178 | get { return result.Location; } | ||
3179 | set { SetLocation(value); } | ||
3180 | } | ||
3181 | public Builder SetLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { | ||
3182 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3183 | result.hasLocation = true; | ||
3184 | result.location_ = value; | ||
3185 | return this; | ||
3186 | } | ||
3187 | public Builder SetLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { | ||
3188 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3189 | result.hasLocation = true; | ||
3190 | result.location_ = builderForValue.Build(); | ||
3191 | return this; | ||
3192 | } | ||
3193 | public Builder MergeLocation(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { | ||
3194 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3195 | if (result.HasLocation && | ||
3196 | result.location_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { | ||
3197 | result.location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.location_).MergeFrom(value).BuildPartial(); | ||
3198 | } else { | ||
3199 | result.location_ = value; | ||
3200 | } | ||
3201 | result.hasLocation = true; | ||
3202 | return this; | ||
3203 | } | ||
3204 | public Builder ClearLocation() { | ||
3205 | result.hasLocation = false; | ||
3206 | result.location_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; | ||
3207 | return this; | ||
3208 | } | ||
3209 | |||
3210 | public pbc::IPopsicleList<float> BoundingSphereList { | ||
3211 | get { return result.boundingSphere_; } | ||
3212 | } | ||
3213 | public int BoundingSphereCount { | ||
3214 | get { return result.BoundingSphereCount; } | ||
3215 | } | ||
3216 | public float GetBoundingSphere(int index) { | ||
3217 | return result.GetBoundingSphere(index); | ||
3218 | } | ||
3219 | public Builder SetBoundingSphere(int index, float value) { | ||
3220 | result.boundingSphere_[index] = value; | ||
3221 | return this; | ||
3222 | } | ||
3223 | public Builder AddBoundingSphere(float value) { | ||
3224 | result.boundingSphere_.Add(value); | ||
3225 | return this; | ||
3226 | } | ||
3227 | public Builder AddRangeBoundingSphere(scg::IEnumerable<float> values) { | ||
3228 | base.AddRange(values, result.boundingSphere_); | ||
3229 | return this; | ||
3230 | } | ||
3231 | public Builder ClearBoundingSphere() { | ||
3232 | result.boundingSphere_.Clear(); | ||
3233 | return this; | ||
3234 | } | ||
3235 | } | ||
3236 | static RetObj() { | ||
3237 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
3238 | } | ||
3239 | } | ||
3240 | |||
3241 | public sealed partial class DelObj : pb::GeneratedMessage<DelObj, DelObj.Builder> { | ||
3242 | private static readonly DelObj defaultInstance = new Builder().BuildPartial(); | ||
3243 | public static DelObj DefaultInstance { | ||
3244 | get { return defaultInstance; } | ||
3245 | } | ||
3246 | |||
3247 | public override DelObj DefaultInstanceForType { | ||
3248 | get { return defaultInstance; } | ||
3249 | } | ||
3250 | |||
3251 | protected override DelObj ThisMessage { | ||
3252 | get { return this; } | ||
3253 | } | ||
3254 | |||
3255 | public static pbd::MessageDescriptor Descriptor { | ||
3256 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__Descriptor; } | ||
3257 | } | ||
3258 | |||
3259 | protected override pb::FieldAccess.FieldAccessorTable<DelObj, DelObj.Builder> InternalFieldAccessors { | ||
3260 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelObj__FieldAccessorTable; } | ||
3261 | } | ||
3262 | |||
3263 | public const int ObjectReferenceFieldNumber = 2; | ||
3264 | private bool hasObjectReference; | ||
3265 | private pb::ByteString objectReference_ = pb::ByteString.Empty; | ||
3266 | public bool HasObjectReference { | ||
3267 | get { return hasObjectReference; } | ||
3268 | } | ||
3269 | public pb::ByteString ObjectReference { | ||
3270 | get { return objectReference_; } | ||
3271 | } | ||
3272 | |||
3273 | public override bool IsInitialized { | ||
3274 | get { | ||
3275 | return true; | ||
3276 | } | ||
3277 | } | ||
3278 | |||
3279 | public override void WriteTo(pb::CodedOutputStream output) { | ||
3280 | if (HasObjectReference) { | ||
3281 | output.WriteBytes(2, ObjectReference); | ||
3282 | } | ||
3283 | UnknownFields.WriteTo(output); | ||
3284 | } | ||
3285 | |||
3286 | private int memoizedSerializedSize = -1; | ||
3287 | public override int SerializedSize { | ||
3288 | get { | ||
3289 | int size = memoizedSerializedSize; | ||
3290 | if (size != -1) return size; | ||
3291 | |||
3292 | size = 0; | ||
3293 | if (HasObjectReference) { | ||
3294 | size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectReference); | ||
3295 | } | ||
3296 | size += UnknownFields.SerializedSize; | ||
3297 | memoizedSerializedSize = size; | ||
3298 | return size; | ||
3299 | } | ||
3300 | } | ||
3301 | |||
3302 | public static DelObj ParseFrom(pb::ByteString data) { | ||
3303 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3304 | } | ||
3305 | public static DelObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
3306 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3307 | } | ||
3308 | public static DelObj ParseFrom(byte[] data) { | ||
3309 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3310 | } | ||
3311 | public static DelObj ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
3312 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3313 | } | ||
3314 | public static DelObj ParseFrom(global::System.IO.Stream input) { | ||
3315 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3316 | } | ||
3317 | public static DelObj ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3318 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3319 | } | ||
3320 | public static DelObj ParseDelimitedFrom(global::System.IO.Stream input) { | ||
3321 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
3322 | } | ||
3323 | public static DelObj ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3324 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
3325 | } | ||
3326 | public static DelObj ParseFrom(pb::CodedInputStream input) { | ||
3327 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3328 | } | ||
3329 | public static DelObj ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3330 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3331 | } | ||
3332 | public static Builder CreateBuilder() { return new Builder(); } | ||
3333 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
3334 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
3335 | public static Builder CreateBuilder(DelObj prototype) { | ||
3336 | return (Builder) new Builder().MergeFrom(prototype); | ||
3337 | } | ||
3338 | |||
3339 | public sealed partial class Builder : pb::GeneratedBuilder<DelObj, Builder> { | ||
3340 | protected override Builder ThisBuilder { | ||
3341 | get { return this; } | ||
3342 | } | ||
3343 | public Builder() {} | ||
3344 | |||
3345 | DelObj result = new DelObj(); | ||
3346 | |||
3347 | protected override DelObj MessageBeingBuilt { | ||
3348 | get { return result; } | ||
3349 | } | ||
3350 | |||
3351 | public override Builder Clear() { | ||
3352 | result = new DelObj(); | ||
3353 | return this; | ||
3354 | } | ||
3355 | |||
3356 | public override Builder Clone() { | ||
3357 | return new Builder().MergeFrom(result); | ||
3358 | } | ||
3359 | |||
3360 | public override pbd::MessageDescriptor DescriptorForType { | ||
3361 | get { return global::Sirikata.Protocol._PBJ_Internal.DelObj.Descriptor; } | ||
3362 | } | ||
3363 | |||
3364 | public override DelObj DefaultInstanceForType { | ||
3365 | get { return global::Sirikata.Protocol._PBJ_Internal.DelObj.DefaultInstance; } | ||
3366 | } | ||
3367 | |||
3368 | public override DelObj BuildPartial() { | ||
3369 | if (result == null) { | ||
3370 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
3371 | } | ||
3372 | DelObj returnMe = result; | ||
3373 | result = null; | ||
3374 | return returnMe; | ||
3375 | } | ||
3376 | |||
3377 | public override Builder MergeFrom(pb::IMessage other) { | ||
3378 | if (other is DelObj) { | ||
3379 | return MergeFrom((DelObj) other); | ||
3380 | } else { | ||
3381 | base.MergeFrom(other); | ||
3382 | return this; | ||
3383 | } | ||
3384 | } | ||
3385 | |||
3386 | public override Builder MergeFrom(DelObj other) { | ||
3387 | if (other == global::Sirikata.Protocol._PBJ_Internal.DelObj.DefaultInstance) return this; | ||
3388 | if (other.HasObjectReference) { | ||
3389 | ObjectReference = other.ObjectReference; | ||
3390 | } | ||
3391 | this.MergeUnknownFields(other.UnknownFields); | ||
3392 | return this; | ||
3393 | } | ||
3394 | |||
3395 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
3396 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
3397 | } | ||
3398 | |||
3399 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3400 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
3401 | while (true) { | ||
3402 | uint tag = input.ReadTag(); | ||
3403 | switch (tag) { | ||
3404 | case 0: { | ||
3405 | if (unknownFields != null) { | ||
3406 | this.UnknownFields = unknownFields.Build(); | ||
3407 | } | ||
3408 | return this; | ||
3409 | } | ||
3410 | default: { | ||
3411 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
3412 | if (unknownFields != null) { | ||
3413 | this.UnknownFields = unknownFields.Build(); | ||
3414 | } | ||
3415 | return this; | ||
3416 | } | ||
3417 | if (unknownFields == null) { | ||
3418 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
3419 | } | ||
3420 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
3421 | break; | ||
3422 | } | ||
3423 | case 18: { | ||
3424 | ObjectReference = input.ReadBytes(); | ||
3425 | break; | ||
3426 | } | ||
3427 | } | ||
3428 | } | ||
3429 | } | ||
3430 | |||
3431 | |||
3432 | public bool HasObjectReference { | ||
3433 | get { return result.HasObjectReference; } | ||
3434 | } | ||
3435 | public pb::ByteString ObjectReference { | ||
3436 | get { return result.ObjectReference; } | ||
3437 | set { SetObjectReference(value); } | ||
3438 | } | ||
3439 | public Builder SetObjectReference(pb::ByteString value) { | ||
3440 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3441 | result.hasObjectReference = true; | ||
3442 | result.objectReference_ = value; | ||
3443 | return this; | ||
3444 | } | ||
3445 | public Builder ClearObjectReference() { | ||
3446 | result.hasObjectReference = false; | ||
3447 | result.objectReference_ = pb::ByteString.Empty; | ||
3448 | return this; | ||
3449 | } | ||
3450 | } | ||
3451 | static DelObj() { | ||
3452 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
3453 | } | ||
3454 | } | ||
3455 | |||
3456 | public sealed partial class NewProxQuery : pb::GeneratedMessage<NewProxQuery, NewProxQuery.Builder> { | ||
3457 | private static readonly NewProxQuery defaultInstance = new Builder().BuildPartial(); | ||
3458 | public static NewProxQuery DefaultInstance { | ||
3459 | get { return defaultInstance; } | ||
3460 | } | ||
3461 | |||
3462 | public override NewProxQuery DefaultInstanceForType { | ||
3463 | get { return defaultInstance; } | ||
3464 | } | ||
3465 | |||
3466 | protected override NewProxQuery ThisMessage { | ||
3467 | get { return this; } | ||
3468 | } | ||
3469 | |||
3470 | public static pbd::MessageDescriptor Descriptor { | ||
3471 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__Descriptor; } | ||
3472 | } | ||
3473 | |||
3474 | protected override pb::FieldAccess.FieldAccessorTable<NewProxQuery, NewProxQuery.Builder> InternalFieldAccessors { | ||
3475 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_NewProxQuery__FieldAccessorTable; } | ||
3476 | } | ||
3477 | |||
3478 | public const int QueryIdFieldNumber = 2; | ||
3479 | private bool hasQueryId; | ||
3480 | private uint queryId_ = 0; | ||
3481 | public bool HasQueryId { | ||
3482 | get { return hasQueryId; } | ||
3483 | } | ||
3484 | [global::System.CLSCompliant(false)] | ||
3485 | public uint QueryId { | ||
3486 | get { return queryId_; } | ||
3487 | } | ||
3488 | |||
3489 | public const int StatelessFieldNumber = 3; | ||
3490 | private bool hasStateless; | ||
3491 | private bool stateless_ = false; | ||
3492 | public bool HasStateless { | ||
3493 | get { return hasStateless; } | ||
3494 | } | ||
3495 | public bool Stateless { | ||
3496 | get { return stateless_; } | ||
3497 | } | ||
3498 | |||
3499 | public const int RelativeCenterFieldNumber = 4; | ||
3500 | private int relativeCenterMemoizedSerializedSize; | ||
3501 | private pbc::PopsicleList<float> relativeCenter_ = new pbc::PopsicleList<float>(); | ||
3502 | public scg::IList<float> RelativeCenterList { | ||
3503 | get { return pbc::Lists.AsReadOnly(relativeCenter_); } | ||
3504 | } | ||
3505 | public int RelativeCenterCount { | ||
3506 | get { return relativeCenter_.Count; } | ||
3507 | } | ||
3508 | public float GetRelativeCenter(int index) { | ||
3509 | return relativeCenter_[index]; | ||
3510 | } | ||
3511 | |||
3512 | public const int AbsoluteCenterFieldNumber = 5; | ||
3513 | private int absoluteCenterMemoizedSerializedSize; | ||
3514 | private pbc::PopsicleList<double> absoluteCenter_ = new pbc::PopsicleList<double>(); | ||
3515 | public scg::IList<double> AbsoluteCenterList { | ||
3516 | get { return pbc::Lists.AsReadOnly(absoluteCenter_); } | ||
3517 | } | ||
3518 | public int AbsoluteCenterCount { | ||
3519 | get { return absoluteCenter_.Count; } | ||
3520 | } | ||
3521 | public double GetAbsoluteCenter(int index) { | ||
3522 | return absoluteCenter_[index]; | ||
3523 | } | ||
3524 | |||
3525 | public const int MaxRadiusFieldNumber = 6; | ||
3526 | private bool hasMaxRadius; | ||
3527 | private float maxRadius_ = 0F; | ||
3528 | public bool HasMaxRadius { | ||
3529 | get { return hasMaxRadius; } | ||
3530 | } | ||
3531 | public float MaxRadius { | ||
3532 | get { return maxRadius_; } | ||
3533 | } | ||
3534 | |||
3535 | public const int MinSolidAngleFieldNumber = 7; | ||
3536 | private bool hasMinSolidAngle; | ||
3537 | private float minSolidAngle_ = 0F; | ||
3538 | public bool HasMinSolidAngle { | ||
3539 | get { return hasMinSolidAngle; } | ||
3540 | } | ||
3541 | public float MinSolidAngle { | ||
3542 | get { return minSolidAngle_; } | ||
3543 | } | ||
3544 | |||
3545 | public override bool IsInitialized { | ||
3546 | get { | ||
3547 | return true; | ||
3548 | } | ||
3549 | } | ||
3550 | |||
3551 | public override void WriteTo(pb::CodedOutputStream output) { | ||
3552 | if (HasQueryId) { | ||
3553 | output.WriteUInt32(2, QueryId); | ||
3554 | } | ||
3555 | if (HasStateless) { | ||
3556 | output.WriteBool(3, Stateless); | ||
3557 | } | ||
3558 | if (relativeCenter_.Count > 0) { | ||
3559 | output.WriteRawVarint32(34); | ||
3560 | output.WriteRawVarint32((uint) relativeCenterMemoizedSerializedSize); | ||
3561 | foreach (float element in relativeCenter_) { | ||
3562 | output.WriteFloatNoTag(element); | ||
3563 | } | ||
3564 | } | ||
3565 | if (absoluteCenter_.Count > 0) { | ||
3566 | output.WriteRawVarint32(42); | ||
3567 | output.WriteRawVarint32((uint) absoluteCenterMemoizedSerializedSize); | ||
3568 | foreach (double element in absoluteCenter_) { | ||
3569 | output.WriteDoubleNoTag(element); | ||
3570 | } | ||
3571 | } | ||
3572 | if (HasMaxRadius) { | ||
3573 | output.WriteFloat(6, MaxRadius); | ||
3574 | } | ||
3575 | if (HasMinSolidAngle) { | ||
3576 | output.WriteFloat(7, MinSolidAngle); | ||
3577 | } | ||
3578 | UnknownFields.WriteTo(output); | ||
3579 | } | ||
3580 | |||
3581 | private int memoizedSerializedSize = -1; | ||
3582 | public override int SerializedSize { | ||
3583 | get { | ||
3584 | int size = memoizedSerializedSize; | ||
3585 | if (size != -1) return size; | ||
3586 | |||
3587 | size = 0; | ||
3588 | if (HasQueryId) { | ||
3589 | size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); | ||
3590 | } | ||
3591 | if (HasStateless) { | ||
3592 | size += pb::CodedOutputStream.ComputeBoolSize(3, Stateless); | ||
3593 | } | ||
3594 | { | ||
3595 | int dataSize = 0; | ||
3596 | dataSize = 4 * relativeCenter_.Count; | ||
3597 | size += dataSize; | ||
3598 | if (relativeCenter_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
3599 | relativeCenterMemoizedSerializedSize = dataSize; | ||
3600 | } | ||
3601 | { | ||
3602 | int dataSize = 0; | ||
3603 | dataSize = 8 * absoluteCenter_.Count; | ||
3604 | size += dataSize; | ||
3605 | if (absoluteCenter_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
3606 | absoluteCenterMemoizedSerializedSize = dataSize; | ||
3607 | } | ||
3608 | if (HasMaxRadius) { | ||
3609 | size += pb::CodedOutputStream.ComputeFloatSize(6, MaxRadius); | ||
3610 | } | ||
3611 | if (HasMinSolidAngle) { | ||
3612 | size += pb::CodedOutputStream.ComputeFloatSize(7, MinSolidAngle); | ||
3613 | } | ||
3614 | size += UnknownFields.SerializedSize; | ||
3615 | memoizedSerializedSize = size; | ||
3616 | return size; | ||
3617 | } | ||
3618 | } | ||
3619 | |||
3620 | public static NewProxQuery ParseFrom(pb::ByteString data) { | ||
3621 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3622 | } | ||
3623 | public static NewProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
3624 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3625 | } | ||
3626 | public static NewProxQuery ParseFrom(byte[] data) { | ||
3627 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
3628 | } | ||
3629 | public static NewProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
3630 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
3631 | } | ||
3632 | public static NewProxQuery ParseFrom(global::System.IO.Stream input) { | ||
3633 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3634 | } | ||
3635 | public static NewProxQuery ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3636 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3637 | } | ||
3638 | public static NewProxQuery ParseDelimitedFrom(global::System.IO.Stream input) { | ||
3639 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
3640 | } | ||
3641 | public static NewProxQuery ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
3642 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
3643 | } | ||
3644 | public static NewProxQuery ParseFrom(pb::CodedInputStream input) { | ||
3645 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
3646 | } | ||
3647 | public static NewProxQuery ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3648 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
3649 | } | ||
3650 | public static Builder CreateBuilder() { return new Builder(); } | ||
3651 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
3652 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
3653 | public static Builder CreateBuilder(NewProxQuery prototype) { | ||
3654 | return (Builder) new Builder().MergeFrom(prototype); | ||
3655 | } | ||
3656 | |||
3657 | public sealed partial class Builder : pb::GeneratedBuilder<NewProxQuery, Builder> { | ||
3658 | protected override Builder ThisBuilder { | ||
3659 | get { return this; } | ||
3660 | } | ||
3661 | public Builder() {} | ||
3662 | |||
3663 | NewProxQuery result = new NewProxQuery(); | ||
3664 | |||
3665 | protected override NewProxQuery MessageBeingBuilt { | ||
3666 | get { return result; } | ||
3667 | } | ||
3668 | |||
3669 | public override Builder Clear() { | ||
3670 | result = new NewProxQuery(); | ||
3671 | return this; | ||
3672 | } | ||
3673 | |||
3674 | public override Builder Clone() { | ||
3675 | return new Builder().MergeFrom(result); | ||
3676 | } | ||
3677 | |||
3678 | public override pbd::MessageDescriptor DescriptorForType { | ||
3679 | get { return global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.Descriptor; } | ||
3680 | } | ||
3681 | |||
3682 | public override NewProxQuery DefaultInstanceForType { | ||
3683 | get { return global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.DefaultInstance; } | ||
3684 | } | ||
3685 | |||
3686 | public override NewProxQuery BuildPartial() { | ||
3687 | if (result == null) { | ||
3688 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
3689 | } | ||
3690 | result.relativeCenter_.MakeReadOnly(); | ||
3691 | result.absoluteCenter_.MakeReadOnly(); | ||
3692 | NewProxQuery returnMe = result; | ||
3693 | result = null; | ||
3694 | return returnMe; | ||
3695 | } | ||
3696 | |||
3697 | public override Builder MergeFrom(pb::IMessage other) { | ||
3698 | if (other is NewProxQuery) { | ||
3699 | return MergeFrom((NewProxQuery) other); | ||
3700 | } else { | ||
3701 | base.MergeFrom(other); | ||
3702 | return this; | ||
3703 | } | ||
3704 | } | ||
3705 | |||
3706 | public override Builder MergeFrom(NewProxQuery other) { | ||
3707 | if (other == global::Sirikata.Protocol._PBJ_Internal.NewProxQuery.DefaultInstance) return this; | ||
3708 | if (other.HasQueryId) { | ||
3709 | QueryId = other.QueryId; | ||
3710 | } | ||
3711 | if (other.HasStateless) { | ||
3712 | Stateless = other.Stateless; | ||
3713 | } | ||
3714 | if (other.relativeCenter_.Count != 0) { | ||
3715 | base.AddRange(other.relativeCenter_, result.relativeCenter_); | ||
3716 | } | ||
3717 | if (other.absoluteCenter_.Count != 0) { | ||
3718 | base.AddRange(other.absoluteCenter_, result.absoluteCenter_); | ||
3719 | } | ||
3720 | if (other.HasMaxRadius) { | ||
3721 | MaxRadius = other.MaxRadius; | ||
3722 | } | ||
3723 | if (other.HasMinSolidAngle) { | ||
3724 | MinSolidAngle = other.MinSolidAngle; | ||
3725 | } | ||
3726 | this.MergeUnknownFields(other.UnknownFields); | ||
3727 | return this; | ||
3728 | } | ||
3729 | |||
3730 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
3731 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
3732 | } | ||
3733 | |||
3734 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
3735 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
3736 | while (true) { | ||
3737 | uint tag = input.ReadTag(); | ||
3738 | switch (tag) { | ||
3739 | case 0: { | ||
3740 | if (unknownFields != null) { | ||
3741 | this.UnknownFields = unknownFields.Build(); | ||
3742 | } | ||
3743 | return this; | ||
3744 | } | ||
3745 | default: { | ||
3746 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
3747 | if (unknownFields != null) { | ||
3748 | this.UnknownFields = unknownFields.Build(); | ||
3749 | } | ||
3750 | return this; | ||
3751 | } | ||
3752 | if (unknownFields == null) { | ||
3753 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
3754 | } | ||
3755 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
3756 | break; | ||
3757 | } | ||
3758 | case 16: { | ||
3759 | QueryId = input.ReadUInt32(); | ||
3760 | break; | ||
3761 | } | ||
3762 | case 24: { | ||
3763 | Stateless = input.ReadBool(); | ||
3764 | break; | ||
3765 | } | ||
3766 | case 34: { | ||
3767 | int length = input.ReadInt32(); | ||
3768 | int limit = input.PushLimit(length); | ||
3769 | while (!input.ReachedLimit) { | ||
3770 | AddRelativeCenter(input.ReadFloat()); | ||
3771 | } | ||
3772 | input.PopLimit(limit); | ||
3773 | break; | ||
3774 | } | ||
3775 | case 42: { | ||
3776 | int length = input.ReadInt32(); | ||
3777 | int limit = input.PushLimit(length); | ||
3778 | while (!input.ReachedLimit) { | ||
3779 | AddAbsoluteCenter(input.ReadDouble()); | ||
3780 | } | ||
3781 | input.PopLimit(limit); | ||
3782 | break; | ||
3783 | } | ||
3784 | case 53: { | ||
3785 | MaxRadius = input.ReadFloat(); | ||
3786 | break; | ||
3787 | } | ||
3788 | case 61: { | ||
3789 | MinSolidAngle = input.ReadFloat(); | ||
3790 | break; | ||
3791 | } | ||
3792 | } | ||
3793 | } | ||
3794 | } | ||
3795 | |||
3796 | |||
3797 | public bool HasQueryId { | ||
3798 | get { return result.HasQueryId; } | ||
3799 | } | ||
3800 | [global::System.CLSCompliant(false)] | ||
3801 | public uint QueryId { | ||
3802 | get { return result.QueryId; } | ||
3803 | set { SetQueryId(value); } | ||
3804 | } | ||
3805 | [global::System.CLSCompliant(false)] | ||
3806 | public Builder SetQueryId(uint value) { | ||
3807 | result.hasQueryId = true; | ||
3808 | result.queryId_ = value; | ||
3809 | return this; | ||
3810 | } | ||
3811 | public Builder ClearQueryId() { | ||
3812 | result.hasQueryId = false; | ||
3813 | result.queryId_ = 0; | ||
3814 | return this; | ||
3815 | } | ||
3816 | |||
3817 | public bool HasStateless { | ||
3818 | get { return result.HasStateless; } | ||
3819 | } | ||
3820 | public bool Stateless { | ||
3821 | get { return result.Stateless; } | ||
3822 | set { SetStateless(value); } | ||
3823 | } | ||
3824 | public Builder SetStateless(bool value) { | ||
3825 | result.hasStateless = true; | ||
3826 | result.stateless_ = value; | ||
3827 | return this; | ||
3828 | } | ||
3829 | public Builder ClearStateless() { | ||
3830 | result.hasStateless = false; | ||
3831 | result.stateless_ = false; | ||
3832 | return this; | ||
3833 | } | ||
3834 | |||
3835 | public pbc::IPopsicleList<float> RelativeCenterList { | ||
3836 | get { return result.relativeCenter_; } | ||
3837 | } | ||
3838 | public int RelativeCenterCount { | ||
3839 | get { return result.RelativeCenterCount; } | ||
3840 | } | ||
3841 | public float GetRelativeCenter(int index) { | ||
3842 | return result.GetRelativeCenter(index); | ||
3843 | } | ||
3844 | public Builder SetRelativeCenter(int index, float value) { | ||
3845 | result.relativeCenter_[index] = value; | ||
3846 | return this; | ||
3847 | } | ||
3848 | public Builder AddRelativeCenter(float value) { | ||
3849 | result.relativeCenter_.Add(value); | ||
3850 | return this; | ||
3851 | } | ||
3852 | public Builder AddRangeRelativeCenter(scg::IEnumerable<float> values) { | ||
3853 | base.AddRange(values, result.relativeCenter_); | ||
3854 | return this; | ||
3855 | } | ||
3856 | public Builder ClearRelativeCenter() { | ||
3857 | result.relativeCenter_.Clear(); | ||
3858 | return this; | ||
3859 | } | ||
3860 | |||
3861 | public pbc::IPopsicleList<double> AbsoluteCenterList { | ||
3862 | get { return result.absoluteCenter_; } | ||
3863 | } | ||
3864 | public int AbsoluteCenterCount { | ||
3865 | get { return result.AbsoluteCenterCount; } | ||
3866 | } | ||
3867 | public double GetAbsoluteCenter(int index) { | ||
3868 | return result.GetAbsoluteCenter(index); | ||
3869 | } | ||
3870 | public Builder SetAbsoluteCenter(int index, double value) { | ||
3871 | result.absoluteCenter_[index] = value; | ||
3872 | return this; | ||
3873 | } | ||
3874 | public Builder AddAbsoluteCenter(double value) { | ||
3875 | result.absoluteCenter_.Add(value); | ||
3876 | return this; | ||
3877 | } | ||
3878 | public Builder AddRangeAbsoluteCenter(scg::IEnumerable<double> values) { | ||
3879 | base.AddRange(values, result.absoluteCenter_); | ||
3880 | return this; | ||
3881 | } | ||
3882 | public Builder ClearAbsoluteCenter() { | ||
3883 | result.absoluteCenter_.Clear(); | ||
3884 | return this; | ||
3885 | } | ||
3886 | |||
3887 | public bool HasMaxRadius { | ||
3888 | get { return result.HasMaxRadius; } | ||
3889 | } | ||
3890 | public float MaxRadius { | ||
3891 | get { return result.MaxRadius; } | ||
3892 | set { SetMaxRadius(value); } | ||
3893 | } | ||
3894 | public Builder SetMaxRadius(float value) { | ||
3895 | result.hasMaxRadius = true; | ||
3896 | result.maxRadius_ = value; | ||
3897 | return this; | ||
3898 | } | ||
3899 | public Builder ClearMaxRadius() { | ||
3900 | result.hasMaxRadius = false; | ||
3901 | result.maxRadius_ = 0F; | ||
3902 | return this; | ||
3903 | } | ||
3904 | |||
3905 | public bool HasMinSolidAngle { | ||
3906 | get { return result.HasMinSolidAngle; } | ||
3907 | } | ||
3908 | public float MinSolidAngle { | ||
3909 | get { return result.MinSolidAngle; } | ||
3910 | set { SetMinSolidAngle(value); } | ||
3911 | } | ||
3912 | public Builder SetMinSolidAngle(float value) { | ||
3913 | result.hasMinSolidAngle = true; | ||
3914 | result.minSolidAngle_ = value; | ||
3915 | return this; | ||
3916 | } | ||
3917 | public Builder ClearMinSolidAngle() { | ||
3918 | result.hasMinSolidAngle = false; | ||
3919 | result.minSolidAngle_ = 0F; | ||
3920 | return this; | ||
3921 | } | ||
3922 | } | ||
3923 | static NewProxQuery() { | ||
3924 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
3925 | } | ||
3926 | } | ||
3927 | |||
3928 | public sealed partial class ProxCall : pb::GeneratedMessage<ProxCall, ProxCall.Builder> { | ||
3929 | private static readonly ProxCall defaultInstance = new Builder().BuildPartial(); | ||
3930 | public static ProxCall DefaultInstance { | ||
3931 | get { return defaultInstance; } | ||
3932 | } | ||
3933 | |||
3934 | public override ProxCall DefaultInstanceForType { | ||
3935 | get { return defaultInstance; } | ||
3936 | } | ||
3937 | |||
3938 | protected override ProxCall ThisMessage { | ||
3939 | get { return this; } | ||
3940 | } | ||
3941 | |||
3942 | public static pbd::MessageDescriptor Descriptor { | ||
3943 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__Descriptor; } | ||
3944 | } | ||
3945 | |||
3946 | protected override pb::FieldAccess.FieldAccessorTable<ProxCall, ProxCall.Builder> InternalFieldAccessors { | ||
3947 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ProxCall__FieldAccessorTable; } | ||
3948 | } | ||
3949 | |||
3950 | #region Nested types | ||
3951 | public static class Types { | ||
3952 | public enum ProximityEvent { | ||
3953 | EXITED_PROXIMITY = 0, | ||
3954 | ENTERED_PROXIMITY = 1, | ||
3955 | STATELESS_PROXIMITY = 2, | ||
3956 | } | ||
3957 | |||
3958 | } | ||
3959 | #endregion | ||
3960 | |||
3961 | public const int QueryIdFieldNumber = 2; | ||
3962 | private bool hasQueryId; | ||
3963 | private uint queryId_ = 0; | ||
3964 | public bool HasQueryId { | ||
3965 | get { return hasQueryId; } | ||
3966 | } | ||
3967 | [global::System.CLSCompliant(false)] | ||
3968 | public uint QueryId { | ||
3969 | get { return queryId_; } | ||
3970 | } | ||
3971 | |||
3972 | public const int ProximateObjectFieldNumber = 3; | ||
3973 | private bool hasProximateObject; | ||
3974 | private pb::ByteString proximateObject_ = pb::ByteString.Empty; | ||
3975 | public bool HasProximateObject { | ||
3976 | get { return hasProximateObject; } | ||
3977 | } | ||
3978 | public pb::ByteString ProximateObject { | ||
3979 | get { return proximateObject_; } | ||
3980 | } | ||
3981 | |||
3982 | public const int ProximityEventFieldNumber = 4; | ||
3983 | private bool hasProximityEvent; | ||
3984 | private global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent proximityEvent_ = global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY; | ||
3985 | public bool HasProximityEvent { | ||
3986 | get { return hasProximityEvent; } | ||
3987 | } | ||
3988 | public global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent ProximityEvent { | ||
3989 | get { return proximityEvent_; } | ||
3990 | } | ||
3991 | |||
3992 | public override bool IsInitialized { | ||
3993 | get { | ||
3994 | if (!hasQueryId) return false; | ||
3995 | if (!hasProximateObject) return false; | ||
3996 | if (!hasProximityEvent) return false; | ||
3997 | return true; | ||
3998 | } | ||
3999 | } | ||
4000 | |||
4001 | public override void WriteTo(pb::CodedOutputStream output) { | ||
4002 | if (HasQueryId) { | ||
4003 | output.WriteUInt32(2, QueryId); | ||
4004 | } | ||
4005 | if (HasProximateObject) { | ||
4006 | output.WriteBytes(3, ProximateObject); | ||
4007 | } | ||
4008 | if (HasProximityEvent) { | ||
4009 | output.WriteEnum(4, (int) ProximityEvent); | ||
4010 | } | ||
4011 | UnknownFields.WriteTo(output); | ||
4012 | } | ||
4013 | |||
4014 | private int memoizedSerializedSize = -1; | ||
4015 | public override int SerializedSize { | ||
4016 | get { | ||
4017 | int size = memoizedSerializedSize; | ||
4018 | if (size != -1) return size; | ||
4019 | |||
4020 | size = 0; | ||
4021 | if (HasQueryId) { | ||
4022 | size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); | ||
4023 | } | ||
4024 | if (HasProximateObject) { | ||
4025 | size += pb::CodedOutputStream.ComputeBytesSize(3, ProximateObject); | ||
4026 | } | ||
4027 | if (HasProximityEvent) { | ||
4028 | size += pb::CodedOutputStream.ComputeEnumSize(4, (int) ProximityEvent); | ||
4029 | } | ||
4030 | size += UnknownFields.SerializedSize; | ||
4031 | memoizedSerializedSize = size; | ||
4032 | return size; | ||
4033 | } | ||
4034 | } | ||
4035 | |||
4036 | public static ProxCall ParseFrom(pb::ByteString data) { | ||
4037 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4038 | } | ||
4039 | public static ProxCall ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
4040 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4041 | } | ||
4042 | public static ProxCall ParseFrom(byte[] data) { | ||
4043 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4044 | } | ||
4045 | public static ProxCall ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
4046 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4047 | } | ||
4048 | public static ProxCall ParseFrom(global::System.IO.Stream input) { | ||
4049 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4050 | } | ||
4051 | public static ProxCall ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4052 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4053 | } | ||
4054 | public static ProxCall ParseDelimitedFrom(global::System.IO.Stream input) { | ||
4055 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
4056 | } | ||
4057 | public static ProxCall ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4058 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
4059 | } | ||
4060 | public static ProxCall ParseFrom(pb::CodedInputStream input) { | ||
4061 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4062 | } | ||
4063 | public static ProxCall ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4064 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4065 | } | ||
4066 | public static Builder CreateBuilder() { return new Builder(); } | ||
4067 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
4068 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
4069 | public static Builder CreateBuilder(ProxCall prototype) { | ||
4070 | return (Builder) new Builder().MergeFrom(prototype); | ||
4071 | } | ||
4072 | |||
4073 | public sealed partial class Builder : pb::GeneratedBuilder<ProxCall, Builder> { | ||
4074 | protected override Builder ThisBuilder { | ||
4075 | get { return this; } | ||
4076 | } | ||
4077 | public Builder() {} | ||
4078 | |||
4079 | ProxCall result = new ProxCall(); | ||
4080 | |||
4081 | protected override ProxCall MessageBeingBuilt { | ||
4082 | get { return result; } | ||
4083 | } | ||
4084 | |||
4085 | public override Builder Clear() { | ||
4086 | result = new ProxCall(); | ||
4087 | return this; | ||
4088 | } | ||
4089 | |||
4090 | public override Builder Clone() { | ||
4091 | return new Builder().MergeFrom(result); | ||
4092 | } | ||
4093 | |||
4094 | public override pbd::MessageDescriptor DescriptorForType { | ||
4095 | get { return global::Sirikata.Protocol._PBJ_Internal.ProxCall.Descriptor; } | ||
4096 | } | ||
4097 | |||
4098 | public override ProxCall DefaultInstanceForType { | ||
4099 | get { return global::Sirikata.Protocol._PBJ_Internal.ProxCall.DefaultInstance; } | ||
4100 | } | ||
4101 | |||
4102 | public override ProxCall BuildPartial() { | ||
4103 | if (result == null) { | ||
4104 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
4105 | } | ||
4106 | ProxCall returnMe = result; | ||
4107 | result = null; | ||
4108 | return returnMe; | ||
4109 | } | ||
4110 | |||
4111 | public override Builder MergeFrom(pb::IMessage other) { | ||
4112 | if (other is ProxCall) { | ||
4113 | return MergeFrom((ProxCall) other); | ||
4114 | } else { | ||
4115 | base.MergeFrom(other); | ||
4116 | return this; | ||
4117 | } | ||
4118 | } | ||
4119 | |||
4120 | public override Builder MergeFrom(ProxCall other) { | ||
4121 | if (other == global::Sirikata.Protocol._PBJ_Internal.ProxCall.DefaultInstance) return this; | ||
4122 | if (other.HasQueryId) { | ||
4123 | QueryId = other.QueryId; | ||
4124 | } | ||
4125 | if (other.HasProximateObject) { | ||
4126 | ProximateObject = other.ProximateObject; | ||
4127 | } | ||
4128 | if (other.HasProximityEvent) { | ||
4129 | ProximityEvent = other.ProximityEvent; | ||
4130 | } | ||
4131 | this.MergeUnknownFields(other.UnknownFields); | ||
4132 | return this; | ||
4133 | } | ||
4134 | |||
4135 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
4136 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
4137 | } | ||
4138 | |||
4139 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4140 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
4141 | while (true) { | ||
4142 | uint tag = input.ReadTag(); | ||
4143 | switch (tag) { | ||
4144 | case 0: { | ||
4145 | if (unknownFields != null) { | ||
4146 | this.UnknownFields = unknownFields.Build(); | ||
4147 | } | ||
4148 | return this; | ||
4149 | } | ||
4150 | default: { | ||
4151 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
4152 | if (unknownFields != null) { | ||
4153 | this.UnknownFields = unknownFields.Build(); | ||
4154 | } | ||
4155 | return this; | ||
4156 | } | ||
4157 | if (unknownFields == null) { | ||
4158 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
4159 | } | ||
4160 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
4161 | break; | ||
4162 | } | ||
4163 | case 16: { | ||
4164 | QueryId = input.ReadUInt32(); | ||
4165 | break; | ||
4166 | } | ||
4167 | case 26: { | ||
4168 | ProximateObject = input.ReadBytes(); | ||
4169 | break; | ||
4170 | } | ||
4171 | case 32: { | ||
4172 | int rawValue = input.ReadEnum(); | ||
4173 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent), rawValue)) { | ||
4174 | if (unknownFields == null) { | ||
4175 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
4176 | } | ||
4177 | unknownFields.MergeVarintField(4, (ulong) rawValue); | ||
4178 | } else { | ||
4179 | ProximityEvent = (global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent) rawValue; | ||
4180 | } | ||
4181 | break; | ||
4182 | } | ||
4183 | } | ||
4184 | } | ||
4185 | } | ||
4186 | |||
4187 | |||
4188 | public bool HasQueryId { | ||
4189 | get { return result.HasQueryId; } | ||
4190 | } | ||
4191 | [global::System.CLSCompliant(false)] | ||
4192 | public uint QueryId { | ||
4193 | get { return result.QueryId; } | ||
4194 | set { SetQueryId(value); } | ||
4195 | } | ||
4196 | [global::System.CLSCompliant(false)] | ||
4197 | public Builder SetQueryId(uint value) { | ||
4198 | result.hasQueryId = true; | ||
4199 | result.queryId_ = value; | ||
4200 | return this; | ||
4201 | } | ||
4202 | public Builder ClearQueryId() { | ||
4203 | result.hasQueryId = false; | ||
4204 | result.queryId_ = 0; | ||
4205 | return this; | ||
4206 | } | ||
4207 | |||
4208 | public bool HasProximateObject { | ||
4209 | get { return result.HasProximateObject; } | ||
4210 | } | ||
4211 | public pb::ByteString ProximateObject { | ||
4212 | get { return result.ProximateObject; } | ||
4213 | set { SetProximateObject(value); } | ||
4214 | } | ||
4215 | public Builder SetProximateObject(pb::ByteString value) { | ||
4216 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
4217 | result.hasProximateObject = true; | ||
4218 | result.proximateObject_ = value; | ||
4219 | return this; | ||
4220 | } | ||
4221 | public Builder ClearProximateObject() { | ||
4222 | result.hasProximateObject = false; | ||
4223 | result.proximateObject_ = pb::ByteString.Empty; | ||
4224 | return this; | ||
4225 | } | ||
4226 | |||
4227 | public bool HasProximityEvent { | ||
4228 | get { return result.HasProximityEvent; } | ||
4229 | } | ||
4230 | public global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent ProximityEvent { | ||
4231 | get { return result.ProximityEvent; } | ||
4232 | set { SetProximityEvent(value); } | ||
4233 | } | ||
4234 | public Builder SetProximityEvent(global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent value) { | ||
4235 | result.hasProximityEvent = true; | ||
4236 | result.proximityEvent_ = value; | ||
4237 | return this; | ||
4238 | } | ||
4239 | public Builder ClearProximityEvent() { | ||
4240 | result.hasProximityEvent = false; | ||
4241 | result.proximityEvent_ = global::Sirikata.Protocol._PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY; | ||
4242 | return this; | ||
4243 | } | ||
4244 | } | ||
4245 | static ProxCall() { | ||
4246 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
4247 | } | ||
4248 | } | ||
4249 | |||
4250 | public sealed partial class DelProxQuery : pb::GeneratedMessage<DelProxQuery, DelProxQuery.Builder> { | ||
4251 | private static readonly DelProxQuery defaultInstance = new Builder().BuildPartial(); | ||
4252 | public static DelProxQuery DefaultInstance { | ||
4253 | get { return defaultInstance; } | ||
4254 | } | ||
4255 | |||
4256 | public override DelProxQuery DefaultInstanceForType { | ||
4257 | get { return defaultInstance; } | ||
4258 | } | ||
4259 | |||
4260 | protected override DelProxQuery ThisMessage { | ||
4261 | get { return this; } | ||
4262 | } | ||
4263 | |||
4264 | public static pbd::MessageDescriptor Descriptor { | ||
4265 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__Descriptor; } | ||
4266 | } | ||
4267 | |||
4268 | protected override pb::FieldAccess.FieldAccessorTable<DelProxQuery, DelProxQuery.Builder> InternalFieldAccessors { | ||
4269 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_DelProxQuery__FieldAccessorTable; } | ||
4270 | } | ||
4271 | |||
4272 | public const int QueryIdFieldNumber = 2; | ||
4273 | private bool hasQueryId; | ||
4274 | private uint queryId_ = 0; | ||
4275 | public bool HasQueryId { | ||
4276 | get { return hasQueryId; } | ||
4277 | } | ||
4278 | [global::System.CLSCompliant(false)] | ||
4279 | public uint QueryId { | ||
4280 | get { return queryId_; } | ||
4281 | } | ||
4282 | |||
4283 | public override bool IsInitialized { | ||
4284 | get { | ||
4285 | return true; | ||
4286 | } | ||
4287 | } | ||
4288 | |||
4289 | public override void WriteTo(pb::CodedOutputStream output) { | ||
4290 | if (HasQueryId) { | ||
4291 | output.WriteUInt32(2, QueryId); | ||
4292 | } | ||
4293 | UnknownFields.WriteTo(output); | ||
4294 | } | ||
4295 | |||
4296 | private int memoizedSerializedSize = -1; | ||
4297 | public override int SerializedSize { | ||
4298 | get { | ||
4299 | int size = memoizedSerializedSize; | ||
4300 | if (size != -1) return size; | ||
4301 | |||
4302 | size = 0; | ||
4303 | if (HasQueryId) { | ||
4304 | size += pb::CodedOutputStream.ComputeUInt32Size(2, QueryId); | ||
4305 | } | ||
4306 | size += UnknownFields.SerializedSize; | ||
4307 | memoizedSerializedSize = size; | ||
4308 | return size; | ||
4309 | } | ||
4310 | } | ||
4311 | |||
4312 | public static DelProxQuery ParseFrom(pb::ByteString data) { | ||
4313 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4314 | } | ||
4315 | public static DelProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
4316 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4317 | } | ||
4318 | public static DelProxQuery ParseFrom(byte[] data) { | ||
4319 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4320 | } | ||
4321 | public static DelProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
4322 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4323 | } | ||
4324 | public static DelProxQuery ParseFrom(global::System.IO.Stream input) { | ||
4325 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4326 | } | ||
4327 | public static DelProxQuery ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4328 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4329 | } | ||
4330 | public static DelProxQuery ParseDelimitedFrom(global::System.IO.Stream input) { | ||
4331 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
4332 | } | ||
4333 | public static DelProxQuery ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4334 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
4335 | } | ||
4336 | public static DelProxQuery ParseFrom(pb::CodedInputStream input) { | ||
4337 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4338 | } | ||
4339 | public static DelProxQuery ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4340 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4341 | } | ||
4342 | public static Builder CreateBuilder() { return new Builder(); } | ||
4343 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
4344 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
4345 | public static Builder CreateBuilder(DelProxQuery prototype) { | ||
4346 | return (Builder) new Builder().MergeFrom(prototype); | ||
4347 | } | ||
4348 | |||
4349 | public sealed partial class Builder : pb::GeneratedBuilder<DelProxQuery, Builder> { | ||
4350 | protected override Builder ThisBuilder { | ||
4351 | get { return this; } | ||
4352 | } | ||
4353 | public Builder() {} | ||
4354 | |||
4355 | DelProxQuery result = new DelProxQuery(); | ||
4356 | |||
4357 | protected override DelProxQuery MessageBeingBuilt { | ||
4358 | get { return result; } | ||
4359 | } | ||
4360 | |||
4361 | public override Builder Clear() { | ||
4362 | result = new DelProxQuery(); | ||
4363 | return this; | ||
4364 | } | ||
4365 | |||
4366 | public override Builder Clone() { | ||
4367 | return new Builder().MergeFrom(result); | ||
4368 | } | ||
4369 | |||
4370 | public override pbd::MessageDescriptor DescriptorForType { | ||
4371 | get { return global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.Descriptor; } | ||
4372 | } | ||
4373 | |||
4374 | public override DelProxQuery DefaultInstanceForType { | ||
4375 | get { return global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.DefaultInstance; } | ||
4376 | } | ||
4377 | |||
4378 | public override DelProxQuery BuildPartial() { | ||
4379 | if (result == null) { | ||
4380 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
4381 | } | ||
4382 | DelProxQuery returnMe = result; | ||
4383 | result = null; | ||
4384 | return returnMe; | ||
4385 | } | ||
4386 | |||
4387 | public override Builder MergeFrom(pb::IMessage other) { | ||
4388 | if (other is DelProxQuery) { | ||
4389 | return MergeFrom((DelProxQuery) other); | ||
4390 | } else { | ||
4391 | base.MergeFrom(other); | ||
4392 | return this; | ||
4393 | } | ||
4394 | } | ||
4395 | |||
4396 | public override Builder MergeFrom(DelProxQuery other) { | ||
4397 | if (other == global::Sirikata.Protocol._PBJ_Internal.DelProxQuery.DefaultInstance) return this; | ||
4398 | if (other.HasQueryId) { | ||
4399 | QueryId = other.QueryId; | ||
4400 | } | ||
4401 | this.MergeUnknownFields(other.UnknownFields); | ||
4402 | return this; | ||
4403 | } | ||
4404 | |||
4405 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
4406 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
4407 | } | ||
4408 | |||
4409 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4410 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
4411 | while (true) { | ||
4412 | uint tag = input.ReadTag(); | ||
4413 | switch (tag) { | ||
4414 | case 0: { | ||
4415 | if (unknownFields != null) { | ||
4416 | this.UnknownFields = unknownFields.Build(); | ||
4417 | } | ||
4418 | return this; | ||
4419 | } | ||
4420 | default: { | ||
4421 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
4422 | if (unknownFields != null) { | ||
4423 | this.UnknownFields = unknownFields.Build(); | ||
4424 | } | ||
4425 | return this; | ||
4426 | } | ||
4427 | if (unknownFields == null) { | ||
4428 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
4429 | } | ||
4430 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
4431 | break; | ||
4432 | } | ||
4433 | case 16: { | ||
4434 | QueryId = input.ReadUInt32(); | ||
4435 | break; | ||
4436 | } | ||
4437 | } | ||
4438 | } | ||
4439 | } | ||
4440 | |||
4441 | |||
4442 | public bool HasQueryId { | ||
4443 | get { return result.HasQueryId; } | ||
4444 | } | ||
4445 | [global::System.CLSCompliant(false)] | ||
4446 | public uint QueryId { | ||
4447 | get { return result.QueryId; } | ||
4448 | set { SetQueryId(value); } | ||
4449 | } | ||
4450 | [global::System.CLSCompliant(false)] | ||
4451 | public Builder SetQueryId(uint value) { | ||
4452 | result.hasQueryId = true; | ||
4453 | result.queryId_ = value; | ||
4454 | return this; | ||
4455 | } | ||
4456 | public Builder ClearQueryId() { | ||
4457 | result.hasQueryId = false; | ||
4458 | result.queryId_ = 0; | ||
4459 | return this; | ||
4460 | } | ||
4461 | } | ||
4462 | static DelProxQuery() { | ||
4463 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
4464 | } | ||
4465 | } | ||
4466 | |||
4467 | public sealed partial class Vector3fProperty : pb::GeneratedMessage<Vector3fProperty, Vector3fProperty.Builder> { | ||
4468 | private static readonly Vector3fProperty defaultInstance = new Builder().BuildPartial(); | ||
4469 | public static Vector3fProperty DefaultInstance { | ||
4470 | get { return defaultInstance; } | ||
4471 | } | ||
4472 | |||
4473 | public override Vector3fProperty DefaultInstanceForType { | ||
4474 | get { return defaultInstance; } | ||
4475 | } | ||
4476 | |||
4477 | protected override Vector3fProperty ThisMessage { | ||
4478 | get { return this; } | ||
4479 | } | ||
4480 | |||
4481 | public static pbd::MessageDescriptor Descriptor { | ||
4482 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__Descriptor; } | ||
4483 | } | ||
4484 | |||
4485 | protected override pb::FieldAccess.FieldAccessorTable<Vector3fProperty, Vector3fProperty.Builder> InternalFieldAccessors { | ||
4486 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_Vector3fProperty__FieldAccessorTable; } | ||
4487 | } | ||
4488 | |||
4489 | public const int ValueFieldNumber = 10; | ||
4490 | private int valueMemoizedSerializedSize; | ||
4491 | private pbc::PopsicleList<float> value_ = new pbc::PopsicleList<float>(); | ||
4492 | public scg::IList<float> ValueList { | ||
4493 | get { return pbc::Lists.AsReadOnly(value_); } | ||
4494 | } | ||
4495 | public int ValueCount { | ||
4496 | get { return value_.Count; } | ||
4497 | } | ||
4498 | public float GetValue(int index) { | ||
4499 | return value_[index]; | ||
4500 | } | ||
4501 | |||
4502 | public override bool IsInitialized { | ||
4503 | get { | ||
4504 | return true; | ||
4505 | } | ||
4506 | } | ||
4507 | |||
4508 | public override void WriteTo(pb::CodedOutputStream output) { | ||
4509 | if (value_.Count > 0) { | ||
4510 | output.WriteRawVarint32(82); | ||
4511 | output.WriteRawVarint32((uint) valueMemoizedSerializedSize); | ||
4512 | foreach (float element in value_) { | ||
4513 | output.WriteFloatNoTag(element); | ||
4514 | } | ||
4515 | } | ||
4516 | UnknownFields.WriteTo(output); | ||
4517 | } | ||
4518 | |||
4519 | private int memoizedSerializedSize = -1; | ||
4520 | public override int SerializedSize { | ||
4521 | get { | ||
4522 | int size = memoizedSerializedSize; | ||
4523 | if (size != -1) return size; | ||
4524 | |||
4525 | size = 0; | ||
4526 | { | ||
4527 | int dataSize = 0; | ||
4528 | dataSize = 4 * value_.Count; | ||
4529 | size += dataSize; | ||
4530 | if (value_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
4531 | valueMemoizedSerializedSize = dataSize; | ||
4532 | } | ||
4533 | size += UnknownFields.SerializedSize; | ||
4534 | memoizedSerializedSize = size; | ||
4535 | return size; | ||
4536 | } | ||
4537 | } | ||
4538 | |||
4539 | public static Vector3fProperty ParseFrom(pb::ByteString data) { | ||
4540 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4541 | } | ||
4542 | public static Vector3fProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
4543 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4544 | } | ||
4545 | public static Vector3fProperty ParseFrom(byte[] data) { | ||
4546 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4547 | } | ||
4548 | public static Vector3fProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
4549 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4550 | } | ||
4551 | public static Vector3fProperty ParseFrom(global::System.IO.Stream input) { | ||
4552 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4553 | } | ||
4554 | public static Vector3fProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4555 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4556 | } | ||
4557 | public static Vector3fProperty ParseDelimitedFrom(global::System.IO.Stream input) { | ||
4558 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
4559 | } | ||
4560 | public static Vector3fProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4561 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
4562 | } | ||
4563 | public static Vector3fProperty ParseFrom(pb::CodedInputStream input) { | ||
4564 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4565 | } | ||
4566 | public static Vector3fProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4567 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4568 | } | ||
4569 | public static Builder CreateBuilder() { return new Builder(); } | ||
4570 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
4571 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
4572 | public static Builder CreateBuilder(Vector3fProperty prototype) { | ||
4573 | return (Builder) new Builder().MergeFrom(prototype); | ||
4574 | } | ||
4575 | |||
4576 | public sealed partial class Builder : pb::GeneratedBuilder<Vector3fProperty, Builder> { | ||
4577 | protected override Builder ThisBuilder { | ||
4578 | get { return this; } | ||
4579 | } | ||
4580 | public Builder() {} | ||
4581 | |||
4582 | Vector3fProperty result = new Vector3fProperty(); | ||
4583 | |||
4584 | protected override Vector3fProperty MessageBeingBuilt { | ||
4585 | get { return result; } | ||
4586 | } | ||
4587 | |||
4588 | public override Builder Clear() { | ||
4589 | result = new Vector3fProperty(); | ||
4590 | return this; | ||
4591 | } | ||
4592 | |||
4593 | public override Builder Clone() { | ||
4594 | return new Builder().MergeFrom(result); | ||
4595 | } | ||
4596 | |||
4597 | public override pbd::MessageDescriptor DescriptorForType { | ||
4598 | get { return global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.Descriptor; } | ||
4599 | } | ||
4600 | |||
4601 | public override Vector3fProperty DefaultInstanceForType { | ||
4602 | get { return global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.DefaultInstance; } | ||
4603 | } | ||
4604 | |||
4605 | public override Vector3fProperty BuildPartial() { | ||
4606 | if (result == null) { | ||
4607 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
4608 | } | ||
4609 | result.value_.MakeReadOnly(); | ||
4610 | Vector3fProperty returnMe = result; | ||
4611 | result = null; | ||
4612 | return returnMe; | ||
4613 | } | ||
4614 | |||
4615 | public override Builder MergeFrom(pb::IMessage other) { | ||
4616 | if (other is Vector3fProperty) { | ||
4617 | return MergeFrom((Vector3fProperty) other); | ||
4618 | } else { | ||
4619 | base.MergeFrom(other); | ||
4620 | return this; | ||
4621 | } | ||
4622 | } | ||
4623 | |||
4624 | public override Builder MergeFrom(Vector3fProperty other) { | ||
4625 | if (other == global::Sirikata.Protocol._PBJ_Internal.Vector3fProperty.DefaultInstance) return this; | ||
4626 | if (other.value_.Count != 0) { | ||
4627 | base.AddRange(other.value_, result.value_); | ||
4628 | } | ||
4629 | this.MergeUnknownFields(other.UnknownFields); | ||
4630 | return this; | ||
4631 | } | ||
4632 | |||
4633 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
4634 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
4635 | } | ||
4636 | |||
4637 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4638 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
4639 | while (true) { | ||
4640 | uint tag = input.ReadTag(); | ||
4641 | switch (tag) { | ||
4642 | case 0: { | ||
4643 | if (unknownFields != null) { | ||
4644 | this.UnknownFields = unknownFields.Build(); | ||
4645 | } | ||
4646 | return this; | ||
4647 | } | ||
4648 | default: { | ||
4649 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
4650 | if (unknownFields != null) { | ||
4651 | this.UnknownFields = unknownFields.Build(); | ||
4652 | } | ||
4653 | return this; | ||
4654 | } | ||
4655 | if (unknownFields == null) { | ||
4656 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
4657 | } | ||
4658 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
4659 | break; | ||
4660 | } | ||
4661 | case 82: { | ||
4662 | int length = input.ReadInt32(); | ||
4663 | int limit = input.PushLimit(length); | ||
4664 | while (!input.ReachedLimit) { | ||
4665 | AddValue(input.ReadFloat()); | ||
4666 | } | ||
4667 | input.PopLimit(limit); | ||
4668 | break; | ||
4669 | } | ||
4670 | } | ||
4671 | } | ||
4672 | } | ||
4673 | |||
4674 | |||
4675 | public pbc::IPopsicleList<float> ValueList { | ||
4676 | get { return result.value_; } | ||
4677 | } | ||
4678 | public int ValueCount { | ||
4679 | get { return result.ValueCount; } | ||
4680 | } | ||
4681 | public float GetValue(int index) { | ||
4682 | return result.GetValue(index); | ||
4683 | } | ||
4684 | public Builder SetValue(int index, float value) { | ||
4685 | result.value_[index] = value; | ||
4686 | return this; | ||
4687 | } | ||
4688 | public Builder AddValue(float value) { | ||
4689 | result.value_.Add(value); | ||
4690 | return this; | ||
4691 | } | ||
4692 | public Builder AddRangeValue(scg::IEnumerable<float> values) { | ||
4693 | base.AddRange(values, result.value_); | ||
4694 | return this; | ||
4695 | } | ||
4696 | public Builder ClearValue() { | ||
4697 | result.value_.Clear(); | ||
4698 | return this; | ||
4699 | } | ||
4700 | } | ||
4701 | static Vector3fProperty() { | ||
4702 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
4703 | } | ||
4704 | } | ||
4705 | |||
4706 | public sealed partial class StringProperty : pb::GeneratedMessage<StringProperty, StringProperty.Builder> { | ||
4707 | private static readonly StringProperty defaultInstance = new Builder().BuildPartial(); | ||
4708 | public static StringProperty DefaultInstance { | ||
4709 | get { return defaultInstance; } | ||
4710 | } | ||
4711 | |||
4712 | public override StringProperty DefaultInstanceForType { | ||
4713 | get { return defaultInstance; } | ||
4714 | } | ||
4715 | |||
4716 | protected override StringProperty ThisMessage { | ||
4717 | get { return this; } | ||
4718 | } | ||
4719 | |||
4720 | public static pbd::MessageDescriptor Descriptor { | ||
4721 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__Descriptor; } | ||
4722 | } | ||
4723 | |||
4724 | protected override pb::FieldAccess.FieldAccessorTable<StringProperty, StringProperty.Builder> InternalFieldAccessors { | ||
4725 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringProperty__FieldAccessorTable; } | ||
4726 | } | ||
4727 | |||
4728 | public const int ValueFieldNumber = 10; | ||
4729 | private bool hasValue; | ||
4730 | private string value_ = ""; | ||
4731 | public bool HasValue { | ||
4732 | get { return hasValue; } | ||
4733 | } | ||
4734 | public string Value { | ||
4735 | get { return value_; } | ||
4736 | } | ||
4737 | |||
4738 | public override bool IsInitialized { | ||
4739 | get { | ||
4740 | return true; | ||
4741 | } | ||
4742 | } | ||
4743 | |||
4744 | public override void WriteTo(pb::CodedOutputStream output) { | ||
4745 | if (HasValue) { | ||
4746 | output.WriteString(10, Value); | ||
4747 | } | ||
4748 | UnknownFields.WriteTo(output); | ||
4749 | } | ||
4750 | |||
4751 | private int memoizedSerializedSize = -1; | ||
4752 | public override int SerializedSize { | ||
4753 | get { | ||
4754 | int size = memoizedSerializedSize; | ||
4755 | if (size != -1) return size; | ||
4756 | |||
4757 | size = 0; | ||
4758 | if (HasValue) { | ||
4759 | size += pb::CodedOutputStream.ComputeStringSize(10, Value); | ||
4760 | } | ||
4761 | size += UnknownFields.SerializedSize; | ||
4762 | memoizedSerializedSize = size; | ||
4763 | return size; | ||
4764 | } | ||
4765 | } | ||
4766 | |||
4767 | public static StringProperty ParseFrom(pb::ByteString data) { | ||
4768 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4769 | } | ||
4770 | public static StringProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
4771 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4772 | } | ||
4773 | public static StringProperty ParseFrom(byte[] data) { | ||
4774 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
4775 | } | ||
4776 | public static StringProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
4777 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
4778 | } | ||
4779 | public static StringProperty ParseFrom(global::System.IO.Stream input) { | ||
4780 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4781 | } | ||
4782 | public static StringProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4783 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4784 | } | ||
4785 | public static StringProperty ParseDelimitedFrom(global::System.IO.Stream input) { | ||
4786 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
4787 | } | ||
4788 | public static StringProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
4789 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
4790 | } | ||
4791 | public static StringProperty ParseFrom(pb::CodedInputStream input) { | ||
4792 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
4793 | } | ||
4794 | public static StringProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4795 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
4796 | } | ||
4797 | public static Builder CreateBuilder() { return new Builder(); } | ||
4798 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
4799 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
4800 | public static Builder CreateBuilder(StringProperty prototype) { | ||
4801 | return (Builder) new Builder().MergeFrom(prototype); | ||
4802 | } | ||
4803 | |||
4804 | public sealed partial class Builder : pb::GeneratedBuilder<StringProperty, Builder> { | ||
4805 | protected override Builder ThisBuilder { | ||
4806 | get { return this; } | ||
4807 | } | ||
4808 | public Builder() {} | ||
4809 | |||
4810 | StringProperty result = new StringProperty(); | ||
4811 | |||
4812 | protected override StringProperty MessageBeingBuilt { | ||
4813 | get { return result; } | ||
4814 | } | ||
4815 | |||
4816 | public override Builder Clear() { | ||
4817 | result = new StringProperty(); | ||
4818 | return this; | ||
4819 | } | ||
4820 | |||
4821 | public override Builder Clone() { | ||
4822 | return new Builder().MergeFrom(result); | ||
4823 | } | ||
4824 | |||
4825 | public override pbd::MessageDescriptor DescriptorForType { | ||
4826 | get { return global::Sirikata.Protocol._PBJ_Internal.StringProperty.Descriptor; } | ||
4827 | } | ||
4828 | |||
4829 | public override StringProperty DefaultInstanceForType { | ||
4830 | get { return global::Sirikata.Protocol._PBJ_Internal.StringProperty.DefaultInstance; } | ||
4831 | } | ||
4832 | |||
4833 | public override StringProperty BuildPartial() { | ||
4834 | if (result == null) { | ||
4835 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
4836 | } | ||
4837 | StringProperty returnMe = result; | ||
4838 | result = null; | ||
4839 | return returnMe; | ||
4840 | } | ||
4841 | |||
4842 | public override Builder MergeFrom(pb::IMessage other) { | ||
4843 | if (other is StringProperty) { | ||
4844 | return MergeFrom((StringProperty) other); | ||
4845 | } else { | ||
4846 | base.MergeFrom(other); | ||
4847 | return this; | ||
4848 | } | ||
4849 | } | ||
4850 | |||
4851 | public override Builder MergeFrom(StringProperty other) { | ||
4852 | if (other == global::Sirikata.Protocol._PBJ_Internal.StringProperty.DefaultInstance) return this; | ||
4853 | if (other.HasValue) { | ||
4854 | Value = other.Value; | ||
4855 | } | ||
4856 | this.MergeUnknownFields(other.UnknownFields); | ||
4857 | return this; | ||
4858 | } | ||
4859 | |||
4860 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
4861 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
4862 | } | ||
4863 | |||
4864 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
4865 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
4866 | while (true) { | ||
4867 | uint tag = input.ReadTag(); | ||
4868 | switch (tag) { | ||
4869 | case 0: { | ||
4870 | if (unknownFields != null) { | ||
4871 | this.UnknownFields = unknownFields.Build(); | ||
4872 | } | ||
4873 | return this; | ||
4874 | } | ||
4875 | default: { | ||
4876 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
4877 | if (unknownFields != null) { | ||
4878 | this.UnknownFields = unknownFields.Build(); | ||
4879 | } | ||
4880 | return this; | ||
4881 | } | ||
4882 | if (unknownFields == null) { | ||
4883 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
4884 | } | ||
4885 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
4886 | break; | ||
4887 | } | ||
4888 | case 82: { | ||
4889 | Value = input.ReadString(); | ||
4890 | break; | ||
4891 | } | ||
4892 | } | ||
4893 | } | ||
4894 | } | ||
4895 | |||
4896 | |||
4897 | public bool HasValue { | ||
4898 | get { return result.HasValue; } | ||
4899 | } | ||
4900 | public string Value { | ||
4901 | get { return result.Value; } | ||
4902 | set { SetValue(value); } | ||
4903 | } | ||
4904 | public Builder SetValue(string value) { | ||
4905 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
4906 | result.hasValue = true; | ||
4907 | result.value_ = value; | ||
4908 | return this; | ||
4909 | } | ||
4910 | public Builder ClearValue() { | ||
4911 | result.hasValue = false; | ||
4912 | result.value_ = ""; | ||
4913 | return this; | ||
4914 | } | ||
4915 | } | ||
4916 | static StringProperty() { | ||
4917 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
4918 | } | ||
4919 | } | ||
4920 | |||
4921 | public sealed partial class StringMapProperty : pb::GeneratedMessage<StringMapProperty, StringMapProperty.Builder> { | ||
4922 | private static readonly StringMapProperty defaultInstance = new Builder().BuildPartial(); | ||
4923 | public static StringMapProperty DefaultInstance { | ||
4924 | get { return defaultInstance; } | ||
4925 | } | ||
4926 | |||
4927 | public override StringMapProperty DefaultInstanceForType { | ||
4928 | get { return defaultInstance; } | ||
4929 | } | ||
4930 | |||
4931 | protected override StringMapProperty ThisMessage { | ||
4932 | get { return this; } | ||
4933 | } | ||
4934 | |||
4935 | public static pbd::MessageDescriptor Descriptor { | ||
4936 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__Descriptor; } | ||
4937 | } | ||
4938 | |||
4939 | protected override pb::FieldAccess.FieldAccessorTable<StringMapProperty, StringMapProperty.Builder> InternalFieldAccessors { | ||
4940 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_StringMapProperty__FieldAccessorTable; } | ||
4941 | } | ||
4942 | |||
4943 | public const int KeysFieldNumber = 2; | ||
4944 | private pbc::PopsicleList<string> keys_ = new pbc::PopsicleList<string>(); | ||
4945 | public scg::IList<string> KeysList { | ||
4946 | get { return pbc::Lists.AsReadOnly(keys_); } | ||
4947 | } | ||
4948 | public int KeysCount { | ||
4949 | get { return keys_.Count; } | ||
4950 | } | ||
4951 | public string GetKeys(int index) { | ||
4952 | return keys_[index]; | ||
4953 | } | ||
4954 | |||
4955 | public const int ValuesFieldNumber = 3; | ||
4956 | private pbc::PopsicleList<string> values_ = new pbc::PopsicleList<string>(); | ||
4957 | public scg::IList<string> ValuesList { | ||
4958 | get { return pbc::Lists.AsReadOnly(values_); } | ||
4959 | } | ||
4960 | public int ValuesCount { | ||
4961 | get { return values_.Count; } | ||
4962 | } | ||
4963 | public string GetValues(int index) { | ||
4964 | return values_[index]; | ||
4965 | } | ||
4966 | |||
4967 | public override bool IsInitialized { | ||
4968 | get { | ||
4969 | return true; | ||
4970 | } | ||
4971 | } | ||
4972 | |||
4973 | public override void WriteTo(pb::CodedOutputStream output) { | ||
4974 | if (keys_.Count > 0) { | ||
4975 | foreach (string element in keys_) { | ||
4976 | output.WriteString(2, element); | ||
4977 | } | ||
4978 | } | ||
4979 | if (values_.Count > 0) { | ||
4980 | foreach (string element in values_) { | ||
4981 | output.WriteString(3, element); | ||
4982 | } | ||
4983 | } | ||
4984 | UnknownFields.WriteTo(output); | ||
4985 | } | ||
4986 | |||
4987 | private int memoizedSerializedSize = -1; | ||
4988 | public override int SerializedSize { | ||
4989 | get { | ||
4990 | int size = memoizedSerializedSize; | ||
4991 | if (size != -1) return size; | ||
4992 | |||
4993 | size = 0; | ||
4994 | { | ||
4995 | int dataSize = 0; | ||
4996 | foreach (string element in KeysList) { | ||
4997 | dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | ||
4998 | } | ||
4999 | size += dataSize; | ||
5000 | size += 1 * keys_.Count; | ||
5001 | } | ||
5002 | { | ||
5003 | int dataSize = 0; | ||
5004 | foreach (string element in ValuesList) { | ||
5005 | dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | ||
5006 | } | ||
5007 | size += dataSize; | ||
5008 | size += 1 * values_.Count; | ||
5009 | } | ||
5010 | size += UnknownFields.SerializedSize; | ||
5011 | memoizedSerializedSize = size; | ||
5012 | return size; | ||
5013 | } | ||
5014 | } | ||
5015 | |||
5016 | public static StringMapProperty ParseFrom(pb::ByteString data) { | ||
5017 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
5018 | } | ||
5019 | public static StringMapProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
5020 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
5021 | } | ||
5022 | public static StringMapProperty ParseFrom(byte[] data) { | ||
5023 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
5024 | } | ||
5025 | public static StringMapProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
5026 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
5027 | } | ||
5028 | public static StringMapProperty ParseFrom(global::System.IO.Stream input) { | ||
5029 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
5030 | } | ||
5031 | public static StringMapProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
5032 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
5033 | } | ||
5034 | public static StringMapProperty ParseDelimitedFrom(global::System.IO.Stream input) { | ||
5035 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
5036 | } | ||
5037 | public static StringMapProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
5038 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
5039 | } | ||
5040 | public static StringMapProperty ParseFrom(pb::CodedInputStream input) { | ||
5041 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
5042 | } | ||
5043 | public static StringMapProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
5044 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
5045 | } | ||
5046 | public static Builder CreateBuilder() { return new Builder(); } | ||
5047 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
5048 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
5049 | public static Builder CreateBuilder(StringMapProperty prototype) { | ||
5050 | return (Builder) new Builder().MergeFrom(prototype); | ||
5051 | } | ||
5052 | |||
5053 | public sealed partial class Builder : pb::GeneratedBuilder<StringMapProperty, Builder> { | ||
5054 | protected override Builder ThisBuilder { | ||
5055 | get { return this; } | ||
5056 | } | ||
5057 | public Builder() {} | ||
5058 | |||
5059 | StringMapProperty result = new StringMapProperty(); | ||
5060 | |||
5061 | protected override StringMapProperty MessageBeingBuilt { | ||
5062 | get { return result; } | ||
5063 | } | ||
5064 | |||
5065 | public override Builder Clear() { | ||
5066 | result = new StringMapProperty(); | ||
5067 | return this; | ||
5068 | } | ||
5069 | |||
5070 | public override Builder Clone() { | ||
5071 | return new Builder().MergeFrom(result); | ||
5072 | } | ||
5073 | |||
5074 | public override pbd::MessageDescriptor DescriptorForType { | ||
5075 | get { return global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.Descriptor; } | ||
5076 | } | ||
5077 | |||
5078 | public override StringMapProperty DefaultInstanceForType { | ||
5079 | get { return global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.DefaultInstance; } | ||
5080 | } | ||
5081 | |||
5082 | public override StringMapProperty BuildPartial() { | ||
5083 | if (result == null) { | ||
5084 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
5085 | } | ||
5086 | result.keys_.MakeReadOnly(); | ||
5087 | result.values_.MakeReadOnly(); | ||
5088 | StringMapProperty returnMe = result; | ||
5089 | result = null; | ||
5090 | return returnMe; | ||
5091 | } | ||
5092 | |||
5093 | public override Builder MergeFrom(pb::IMessage other) { | ||
5094 | if (other is StringMapProperty) { | ||
5095 | return MergeFrom((StringMapProperty) other); | ||
5096 | } else { | ||
5097 | base.MergeFrom(other); | ||
5098 | return this; | ||
5099 | } | ||
5100 | } | ||
5101 | |||
5102 | public override Builder MergeFrom(StringMapProperty other) { | ||
5103 | if (other == global::Sirikata.Protocol._PBJ_Internal.StringMapProperty.DefaultInstance) return this; | ||
5104 | if (other.keys_.Count != 0) { | ||
5105 | base.AddRange(other.keys_, result.keys_); | ||
5106 | } | ||
5107 | if (other.values_.Count != 0) { | ||
5108 | base.AddRange(other.values_, result.values_); | ||
5109 | } | ||
5110 | this.MergeUnknownFields(other.UnknownFields); | ||
5111 | return this; | ||
5112 | } | ||
5113 | |||
5114 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
5115 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
5116 | } | ||
5117 | |||
5118 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
5119 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
5120 | while (true) { | ||
5121 | uint tag = input.ReadTag(); | ||
5122 | switch (tag) { | ||
5123 | case 0: { | ||
5124 | if (unknownFields != null) { | ||
5125 | this.UnknownFields = unknownFields.Build(); | ||
5126 | } | ||
5127 | return this; | ||
5128 | } | ||
5129 | default: { | ||
5130 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
5131 | if (unknownFields != null) { | ||
5132 | this.UnknownFields = unknownFields.Build(); | ||
5133 | } | ||
5134 | return this; | ||
5135 | } | ||
5136 | if (unknownFields == null) { | ||
5137 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
5138 | } | ||
5139 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
5140 | break; | ||
5141 | } | ||
5142 | case 18: { | ||
5143 | AddKeys(input.ReadString()); | ||
5144 | break; | ||
5145 | } | ||
5146 | case 26: { | ||
5147 | AddValues(input.ReadString()); | ||
5148 | break; | ||
5149 | } | ||
5150 | } | ||
5151 | } | ||
5152 | } | ||
5153 | |||
5154 | |||
5155 | public pbc::IPopsicleList<string> KeysList { | ||
5156 | get { return result.keys_; } | ||
5157 | } | ||
5158 | public int KeysCount { | ||
5159 | get { return result.KeysCount; } | ||
5160 | } | ||
5161 | public string GetKeys(int index) { | ||
5162 | return result.GetKeys(index); | ||
5163 | } | ||
5164 | public Builder SetKeys(int index, string value) { | ||
5165 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
5166 | result.keys_[index] = value; | ||
5167 | return this; | ||
5168 | } | ||
5169 | public Builder AddKeys(string value) { | ||
5170 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
5171 | result.keys_.Add(value); | ||
5172 | return this; | ||
5173 | } | ||
5174 | public Builder AddRangeKeys(scg::IEnumerable<string> values) { | ||
5175 | base.AddRange(values, result.keys_); | ||
5176 | return this; | ||
5177 | } | ||
5178 | public Builder ClearKeys() { | ||
5179 | result.keys_.Clear(); | ||
5180 | return this; | ||
5181 | } | ||
5182 | |||
5183 | public pbc::IPopsicleList<string> ValuesList { | ||
5184 | get { return result.values_; } | ||
5185 | } | ||
5186 | public int ValuesCount { | ||
5187 | get { return result.ValuesCount; } | ||
5188 | } | ||
5189 | public string GetValues(int index) { | ||
5190 | return result.GetValues(index); | ||
5191 | } | ||
5192 | public Builder SetValues(int index, string value) { | ||
5193 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
5194 | result.values_[index] = value; | ||
5195 | return this; | ||
5196 | } | ||
5197 | public Builder AddValues(string value) { | ||
5198 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
5199 | result.values_.Add(value); | ||
5200 | return this; | ||
5201 | } | ||
5202 | public Builder AddRangeValues(scg::IEnumerable<string> values) { | ||
5203 | base.AddRange(values, result.values_); | ||
5204 | return this; | ||
5205 | } | ||
5206 | public Builder ClearValues() { | ||
5207 | result.values_.Clear(); | ||
5208 | return this; | ||
5209 | } | ||
5210 | } | ||
5211 | static StringMapProperty() { | ||
5212 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
5213 | } | ||
5214 | } | ||
5215 | |||
5216 | public sealed partial class PhysicalParameters : pb::GeneratedMessage<PhysicalParameters, PhysicalParameters.Builder> { | ||
5217 | private static readonly PhysicalParameters defaultInstance = new Builder().BuildPartial(); | ||
5218 | public static PhysicalParameters DefaultInstance { | ||
5219 | get { return defaultInstance; } | ||
5220 | } | ||
5221 | |||
5222 | public override PhysicalParameters DefaultInstanceForType { | ||
5223 | get { return defaultInstance; } | ||
5224 | } | ||
5225 | |||
5226 | protected override PhysicalParameters ThisMessage { | ||
5227 | get { return this; } | ||
5228 | } | ||
5229 | |||
5230 | public static pbd::MessageDescriptor Descriptor { | ||
5231 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__Descriptor; } | ||
5232 | } | ||
5233 | |||
5234 | protected override pb::FieldAccess.FieldAccessorTable<PhysicalParameters, PhysicalParameters.Builder> InternalFieldAccessors { | ||
5235 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_PhysicalParameters__FieldAccessorTable; } | ||
5236 | } | ||
5237 | |||
5238 | #region Nested types | ||
5239 | public static class Types { | ||
5240 | public enum Mode { | ||
5241 | NONPHYSICAL = 0, | ||
5242 | STATIC = 1, | ||
5243 | DYNAMICBOX = 2, | ||
5244 | DYNAMICSPHERE = 3, | ||
5245 | DYNAMICCYLINDER = 4, | ||
5246 | CHARACTER = 5, | ||
5247 | } | ||
5248 | |||
5249 | } | ||
5250 | #endregion | ||
5251 | |||
5252 | public const int ModeFieldNumber = 2; | ||
5253 | private bool hasMode; | ||
5254 | private global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode mode_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL; | ||
5255 | public bool HasMode { | ||
5256 | get { return hasMode; } | ||
5257 | } | ||
5258 | public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode Mode { | ||
5259 | get { return mode_; } | ||
5260 | } | ||
5261 | |||
5262 | public const int DensityFieldNumber = 3; | ||
5263 | private bool hasDensity; | ||
5264 | private float density_ = 0F; | ||
5265 | public bool HasDensity { | ||
5266 | get { return hasDensity; } | ||
5267 | } | ||
5268 | public float Density { | ||
5269 | get { return density_; } | ||
5270 | } | ||
5271 | |||
5272 | public const int FrictionFieldNumber = 4; | ||
5273 | private bool hasFriction; | ||
5274 | private float friction_ = 0F; | ||
5275 | public bool HasFriction { | ||
5276 | get { return hasFriction; } | ||
5277 | } | ||
5278 | public float Friction { | ||
5279 | get { return friction_; } | ||
5280 | } | ||
5281 | |||
5282 | public const int BounceFieldNumber = 5; | ||
5283 | private bool hasBounce; | ||
5284 | private float bounce_ = 0F; | ||
5285 | public bool HasBounce { | ||
5286 | get { return hasBounce; } | ||
5287 | } | ||
5288 | public float Bounce { | ||
5289 | get { return bounce_; } | ||
5290 | } | ||
5291 | |||
5292 | public const int HullFieldNumber = 6; | ||
5293 | private int hullMemoizedSerializedSize; | ||
5294 | private pbc::PopsicleList<float> hull_ = new pbc::PopsicleList<float>(); | ||
5295 | public scg::IList<float> HullList { | ||
5296 | get { return pbc::Lists.AsReadOnly(hull_); } | ||
5297 | } | ||
5298 | public int HullCount { | ||
5299 | get { return hull_.Count; } | ||
5300 | } | ||
5301 | public float GetHull(int index) { | ||
5302 | return hull_[index]; | ||
5303 | } | ||
5304 | |||
5305 | public const int CollideMsgFieldNumber = 16; | ||
5306 | private bool hasCollideMsg; | ||
5307 | private uint collideMsg_ = 0; | ||
5308 | public bool HasCollideMsg { | ||
5309 | get { return hasCollideMsg; } | ||
5310 | } | ||
5311 | [global::System.CLSCompliant(false)] | ||
5312 | public uint CollideMsg { | ||
5313 | get { return collideMsg_; } | ||
5314 | } | ||
5315 | |||
5316 | public const int CollideMaskFieldNumber = 17; | ||
5317 | private bool hasCollideMask; | ||
5318 | private uint collideMask_ = 0; | ||
5319 | public bool HasCollideMask { | ||
5320 | get { return hasCollideMask; } | ||
5321 | } | ||
5322 | [global::System.CLSCompliant(false)] | ||
5323 | public uint CollideMask { | ||
5324 | get { return collideMask_; } | ||
5325 | } | ||
5326 | |||
5327 | public const int GravityFieldNumber = 18; | ||
5328 | private bool hasGravity; | ||
5329 | private float gravity_ = 0F; | ||
5330 | public bool HasGravity { | ||
5331 | get { return hasGravity; } | ||
5332 | } | ||
5333 | public float Gravity { | ||
5334 | get { return gravity_; } | ||
5335 | } | ||
5336 | |||
5337 | public override bool IsInitialized { | ||
5338 | get { | ||
5339 | return true; | ||
5340 | } | ||
5341 | } | ||
5342 | |||
5343 | public override void WriteTo(pb::CodedOutputStream output) { | ||
5344 | if (HasMode) { | ||
5345 | output.WriteEnum(2, (int) Mode); | ||
5346 | } | ||
5347 | if (HasDensity) { | ||
5348 | output.WriteFloat(3, Density); | ||
5349 | } | ||
5350 | if (HasFriction) { | ||
5351 | output.WriteFloat(4, Friction); | ||
5352 | } | ||
5353 | if (HasBounce) { | ||
5354 | output.WriteFloat(5, Bounce); | ||
5355 | } | ||
5356 | if (hull_.Count > 0) { | ||
5357 | output.WriteRawVarint32(50); | ||
5358 | output.WriteRawVarint32((uint) hullMemoizedSerializedSize); | ||
5359 | foreach (float element in hull_) { | ||
5360 | output.WriteFloatNoTag(element); | ||
5361 | } | ||
5362 | } | ||
5363 | if (HasCollideMsg) { | ||
5364 | output.WriteUInt32(16, CollideMsg); | ||
5365 | } | ||
5366 | if (HasCollideMask) { | ||
5367 | output.WriteUInt32(17, CollideMask); | ||
5368 | } | ||
5369 | if (HasGravity) { | ||
5370 | output.WriteFloat(18, Gravity); | ||
5371 | } | ||
5372 | UnknownFields.WriteTo(output); | ||
5373 | } | ||
5374 | |||
5375 | private int memoizedSerializedSize = -1; | ||
5376 | public override int SerializedSize { | ||
5377 | get { | ||
5378 | int size = memoizedSerializedSize; | ||
5379 | if (size != -1) return size; | ||
5380 | |||
5381 | size = 0; | ||
5382 | if (HasMode) { | ||
5383 | size += pb::CodedOutputStream.ComputeEnumSize(2, (int) Mode); | ||
5384 | } | ||
5385 | if (HasDensity) { | ||
5386 | size += pb::CodedOutputStream.ComputeFloatSize(3, Density); | ||
5387 | } | ||
5388 | if (HasFriction) { | ||
5389 | size += pb::CodedOutputStream.ComputeFloatSize(4, Friction); | ||
5390 | } | ||
5391 | if (HasBounce) { | ||
5392 | size += pb::CodedOutputStream.ComputeFloatSize(5, Bounce); | ||
5393 | } | ||
5394 | { | ||
5395 | int dataSize = 0; | ||
5396 | dataSize = 4 * hull_.Count; | ||
5397 | size += dataSize; | ||
5398 | if (hull_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
5399 | hullMemoizedSerializedSize = dataSize; | ||
5400 | } | ||
5401 | if (HasCollideMsg) { | ||
5402 | size += pb::CodedOutputStream.ComputeUInt32Size(16, CollideMsg); | ||
5403 | } | ||
5404 | if (HasCollideMask) { | ||
5405 | size += pb::CodedOutputStream.ComputeUInt32Size(17, CollideMask); | ||
5406 | } | ||
5407 | if (HasGravity) { | ||
5408 | size += pb::CodedOutputStream.ComputeFloatSize(18, Gravity); | ||
5409 | } | ||
5410 | size += UnknownFields.SerializedSize; | ||
5411 | memoizedSerializedSize = size; | ||
5412 | return size; | ||
5413 | } | ||
5414 | } | ||
5415 | |||
5416 | public static PhysicalParameters ParseFrom(pb::ByteString data) { | ||
5417 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
5418 | } | ||
5419 | public static PhysicalParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
5420 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
5421 | } | ||
5422 | public static PhysicalParameters ParseFrom(byte[] data) { | ||
5423 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
5424 | } | ||
5425 | public static PhysicalParameters ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
5426 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
5427 | } | ||
5428 | public static PhysicalParameters ParseFrom(global::System.IO.Stream input) { | ||
5429 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
5430 | } | ||
5431 | public static PhysicalParameters ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
5432 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
5433 | } | ||
5434 | public static PhysicalParameters ParseDelimitedFrom(global::System.IO.Stream input) { | ||
5435 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
5436 | } | ||
5437 | public static PhysicalParameters ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
5438 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
5439 | } | ||
5440 | public static PhysicalParameters ParseFrom(pb::CodedInputStream input) { | ||
5441 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
5442 | } | ||
5443 | public static PhysicalParameters ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
5444 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
5445 | } | ||
5446 | public static Builder CreateBuilder() { return new Builder(); } | ||
5447 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
5448 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
5449 | public static Builder CreateBuilder(PhysicalParameters prototype) { | ||
5450 | return (Builder) new Builder().MergeFrom(prototype); | ||
5451 | } | ||
5452 | |||
5453 | public sealed partial class Builder : pb::GeneratedBuilder<PhysicalParameters, Builder> { | ||
5454 | protected override Builder ThisBuilder { | ||
5455 | get { return this; } | ||
5456 | } | ||
5457 | public Builder() {} | ||
5458 | |||
5459 | PhysicalParameters result = new PhysicalParameters(); | ||
5460 | |||
5461 | protected override PhysicalParameters MessageBeingBuilt { | ||
5462 | get { return result; } | ||
5463 | } | ||
5464 | |||
5465 | public override Builder Clear() { | ||
5466 | result = new PhysicalParameters(); | ||
5467 | return this; | ||
5468 | } | ||
5469 | |||
5470 | public override Builder Clone() { | ||
5471 | return new Builder().MergeFrom(result); | ||
5472 | } | ||
5473 | |||
5474 | public override pbd::MessageDescriptor DescriptorForType { | ||
5475 | get { return global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Descriptor; } | ||
5476 | } | ||
5477 | |||
5478 | public override PhysicalParameters DefaultInstanceForType { | ||
5479 | get { return global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; } | ||
5480 | } | ||
5481 | |||
5482 | public override PhysicalParameters BuildPartial() { | ||
5483 | if (result == null) { | ||
5484 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
5485 | } | ||
5486 | result.hull_.MakeReadOnly(); | ||
5487 | PhysicalParameters returnMe = result; | ||
5488 | result = null; | ||
5489 | return returnMe; | ||
5490 | } | ||
5491 | |||
5492 | public override Builder MergeFrom(pb::IMessage other) { | ||
5493 | if (other is PhysicalParameters) { | ||
5494 | return MergeFrom((PhysicalParameters) other); | ||
5495 | } else { | ||
5496 | base.MergeFrom(other); | ||
5497 | return this; | ||
5498 | } | ||
5499 | } | ||
5500 | |||
5501 | public override Builder MergeFrom(PhysicalParameters other) { | ||
5502 | if (other == global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance) return this; | ||
5503 | if (other.HasMode) { | ||
5504 | Mode = other.Mode; | ||
5505 | } | ||
5506 | if (other.HasDensity) { | ||
5507 | Density = other.Density; | ||
5508 | } | ||
5509 | if (other.HasFriction) { | ||
5510 | Friction = other.Friction; | ||
5511 | } | ||
5512 | if (other.HasBounce) { | ||
5513 | Bounce = other.Bounce; | ||
5514 | } | ||
5515 | if (other.hull_.Count != 0) { | ||
5516 | base.AddRange(other.hull_, result.hull_); | ||
5517 | } | ||
5518 | if (other.HasCollideMsg) { | ||
5519 | CollideMsg = other.CollideMsg; | ||
5520 | } | ||
5521 | if (other.HasCollideMask) { | ||
5522 | CollideMask = other.CollideMask; | ||
5523 | } | ||
5524 | if (other.HasGravity) { | ||
5525 | Gravity = other.Gravity; | ||
5526 | } | ||
5527 | this.MergeUnknownFields(other.UnknownFields); | ||
5528 | return this; | ||
5529 | } | ||
5530 | |||
5531 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
5532 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
5533 | } | ||
5534 | |||
5535 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
5536 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
5537 | while (true) { | ||
5538 | uint tag = input.ReadTag(); | ||
5539 | switch (tag) { | ||
5540 | case 0: { | ||
5541 | if (unknownFields != null) { | ||
5542 | this.UnknownFields = unknownFields.Build(); | ||
5543 | } | ||
5544 | return this; | ||
5545 | } | ||
5546 | default: { | ||
5547 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
5548 | if (unknownFields != null) { | ||
5549 | this.UnknownFields = unknownFields.Build(); | ||
5550 | } | ||
5551 | return this; | ||
5552 | } | ||
5553 | if (unknownFields == null) { | ||
5554 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
5555 | } | ||
5556 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
5557 | break; | ||
5558 | } | ||
5559 | case 16: { | ||
5560 | int rawValue = input.ReadEnum(); | ||
5561 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode), rawValue)) { | ||
5562 | if (unknownFields == null) { | ||
5563 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
5564 | } | ||
5565 | unknownFields.MergeVarintField(2, (ulong) rawValue); | ||
5566 | } else { | ||
5567 | Mode = (global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode) rawValue; | ||
5568 | } | ||
5569 | break; | ||
5570 | } | ||
5571 | case 29: { | ||
5572 | Density = input.ReadFloat(); | ||
5573 | break; | ||
5574 | } | ||
5575 | case 37: { | ||
5576 | Friction = input.ReadFloat(); | ||
5577 | break; | ||
5578 | } | ||
5579 | case 45: { | ||
5580 | Bounce = input.ReadFloat(); | ||
5581 | break; | ||
5582 | } | ||
5583 | case 50: { | ||
5584 | int length = input.ReadInt32(); | ||
5585 | int limit = input.PushLimit(length); | ||
5586 | while (!input.ReachedLimit) { | ||
5587 | AddHull(input.ReadFloat()); | ||
5588 | } | ||
5589 | input.PopLimit(limit); | ||
5590 | break; | ||
5591 | } | ||
5592 | case 128: { | ||
5593 | CollideMsg = input.ReadUInt32(); | ||
5594 | break; | ||
5595 | } | ||
5596 | case 136: { | ||
5597 | CollideMask = input.ReadUInt32(); | ||
5598 | break; | ||
5599 | } | ||
5600 | case 149: { | ||
5601 | Gravity = input.ReadFloat(); | ||
5602 | break; | ||
5603 | } | ||
5604 | } | ||
5605 | } | ||
5606 | } | ||
5607 | |||
5608 | |||
5609 | public bool HasMode { | ||
5610 | get { return result.HasMode; } | ||
5611 | } | ||
5612 | public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode Mode { | ||
5613 | get { return result.Mode; } | ||
5614 | set { SetMode(value); } | ||
5615 | } | ||
5616 | public Builder SetMode(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode value) { | ||
5617 | result.hasMode = true; | ||
5618 | result.mode_ = value; | ||
5619 | return this; | ||
5620 | } | ||
5621 | public Builder ClearMode() { | ||
5622 | result.hasMode = false; | ||
5623 | result.mode_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL; | ||
5624 | return this; | ||
5625 | } | ||
5626 | |||
5627 | public bool HasDensity { | ||
5628 | get { return result.HasDensity; } | ||
5629 | } | ||
5630 | public float Density { | ||
5631 | get { return result.Density; } | ||
5632 | set { SetDensity(value); } | ||
5633 | } | ||
5634 | public Builder SetDensity(float value) { | ||
5635 | result.hasDensity = true; | ||
5636 | result.density_ = value; | ||
5637 | return this; | ||
5638 | } | ||
5639 | public Builder ClearDensity() { | ||
5640 | result.hasDensity = false; | ||
5641 | result.density_ = 0F; | ||
5642 | return this; | ||
5643 | } | ||
5644 | |||
5645 | public bool HasFriction { | ||
5646 | get { return result.HasFriction; } | ||
5647 | } | ||
5648 | public float Friction { | ||
5649 | get { return result.Friction; } | ||
5650 | set { SetFriction(value); } | ||
5651 | } | ||
5652 | public Builder SetFriction(float value) { | ||
5653 | result.hasFriction = true; | ||
5654 | result.friction_ = value; | ||
5655 | return this; | ||
5656 | } | ||
5657 | public Builder ClearFriction() { | ||
5658 | result.hasFriction = false; | ||
5659 | result.friction_ = 0F; | ||
5660 | return this; | ||
5661 | } | ||
5662 | |||
5663 | public bool HasBounce { | ||
5664 | get { return result.HasBounce; } | ||
5665 | } | ||
5666 | public float Bounce { | ||
5667 | get { return result.Bounce; } | ||
5668 | set { SetBounce(value); } | ||
5669 | } | ||
5670 | public Builder SetBounce(float value) { | ||
5671 | result.hasBounce = true; | ||
5672 | result.bounce_ = value; | ||
5673 | return this; | ||
5674 | } | ||
5675 | public Builder ClearBounce() { | ||
5676 | result.hasBounce = false; | ||
5677 | result.bounce_ = 0F; | ||
5678 | return this; | ||
5679 | } | ||
5680 | |||
5681 | public pbc::IPopsicleList<float> HullList { | ||
5682 | get { return result.hull_; } | ||
5683 | } | ||
5684 | public int HullCount { | ||
5685 | get { return result.HullCount; } | ||
5686 | } | ||
5687 | public float GetHull(int index) { | ||
5688 | return result.GetHull(index); | ||
5689 | } | ||
5690 | public Builder SetHull(int index, float value) { | ||
5691 | result.hull_[index] = value; | ||
5692 | return this; | ||
5693 | } | ||
5694 | public Builder AddHull(float value) { | ||
5695 | result.hull_.Add(value); | ||
5696 | return this; | ||
5697 | } | ||
5698 | public Builder AddRangeHull(scg::IEnumerable<float> values) { | ||
5699 | base.AddRange(values, result.hull_); | ||
5700 | return this; | ||
5701 | } | ||
5702 | public Builder ClearHull() { | ||
5703 | result.hull_.Clear(); | ||
5704 | return this; | ||
5705 | } | ||
5706 | |||
5707 | public bool HasCollideMsg { | ||
5708 | get { return result.HasCollideMsg; } | ||
5709 | } | ||
5710 | [global::System.CLSCompliant(false)] | ||
5711 | public uint CollideMsg { | ||
5712 | get { return result.CollideMsg; } | ||
5713 | set { SetCollideMsg(value); } | ||
5714 | } | ||
5715 | [global::System.CLSCompliant(false)] | ||
5716 | public Builder SetCollideMsg(uint value) { | ||
5717 | result.hasCollideMsg = true; | ||
5718 | result.collideMsg_ = value; | ||
5719 | return this; | ||
5720 | } | ||
5721 | public Builder ClearCollideMsg() { | ||
5722 | result.hasCollideMsg = false; | ||
5723 | result.collideMsg_ = 0; | ||
5724 | return this; | ||
5725 | } | ||
5726 | |||
5727 | public bool HasCollideMask { | ||
5728 | get { return result.HasCollideMask; } | ||
5729 | } | ||
5730 | [global::System.CLSCompliant(false)] | ||
5731 | public uint CollideMask { | ||
5732 | get { return result.CollideMask; } | ||
5733 | set { SetCollideMask(value); } | ||
5734 | } | ||
5735 | [global::System.CLSCompliant(false)] | ||
5736 | public Builder SetCollideMask(uint value) { | ||
5737 | result.hasCollideMask = true; | ||
5738 | result.collideMask_ = value; | ||
5739 | return this; | ||
5740 | } | ||
5741 | public Builder ClearCollideMask() { | ||
5742 | result.hasCollideMask = false; | ||
5743 | result.collideMask_ = 0; | ||
5744 | return this; | ||
5745 | } | ||
5746 | |||
5747 | public bool HasGravity { | ||
5748 | get { return result.HasGravity; } | ||
5749 | } | ||
5750 | public float Gravity { | ||
5751 | get { return result.Gravity; } | ||
5752 | set { SetGravity(value); } | ||
5753 | } | ||
5754 | public Builder SetGravity(float value) { | ||
5755 | result.hasGravity = true; | ||
5756 | result.gravity_ = value; | ||
5757 | return this; | ||
5758 | } | ||
5759 | public Builder ClearGravity() { | ||
5760 | result.hasGravity = false; | ||
5761 | result.gravity_ = 0F; | ||
5762 | return this; | ||
5763 | } | ||
5764 | } | ||
5765 | static PhysicalParameters() { | ||
5766 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
5767 | } | ||
5768 | } | ||
5769 | |||
5770 | public sealed partial class LightInfoProperty : pb::GeneratedMessage<LightInfoProperty, LightInfoProperty.Builder> { | ||
5771 | private static readonly LightInfoProperty defaultInstance = new Builder().BuildPartial(); | ||
5772 | public static LightInfoProperty DefaultInstance { | ||
5773 | get { return defaultInstance; } | ||
5774 | } | ||
5775 | |||
5776 | public override LightInfoProperty DefaultInstanceForType { | ||
5777 | get { return defaultInstance; } | ||
5778 | } | ||
5779 | |||
5780 | protected override LightInfoProperty ThisMessage { | ||
5781 | get { return this; } | ||
5782 | } | ||
5783 | |||
5784 | public static pbd::MessageDescriptor Descriptor { | ||
5785 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__Descriptor; } | ||
5786 | } | ||
5787 | |||
5788 | protected override pb::FieldAccess.FieldAccessorTable<LightInfoProperty, LightInfoProperty.Builder> InternalFieldAccessors { | ||
5789 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_LightInfoProperty__FieldAccessorTable; } | ||
5790 | } | ||
5791 | |||
5792 | #region Nested types | ||
5793 | public static class Types { | ||
5794 | public enum LightTypes { | ||
5795 | POINT = 0, | ||
5796 | SPOTLIGHT = 1, | ||
5797 | DIRECTIONAL = 2, | ||
5798 | } | ||
5799 | |||
5800 | } | ||
5801 | #endregion | ||
5802 | |||
5803 | public const int DiffuseColorFieldNumber = 3; | ||
5804 | private int diffuseColorMemoizedSerializedSize; | ||
5805 | private pbc::PopsicleList<float> diffuseColor_ = new pbc::PopsicleList<float>(); | ||
5806 | public scg::IList<float> DiffuseColorList { | ||
5807 | get { return pbc::Lists.AsReadOnly(diffuseColor_); } | ||
5808 | } | ||
5809 | public int DiffuseColorCount { | ||
5810 | get { return diffuseColor_.Count; } | ||
5811 | } | ||
5812 | public float GetDiffuseColor(int index) { | ||
5813 | return diffuseColor_[index]; | ||
5814 | } | ||
5815 | |||
5816 | public const int SpecularColorFieldNumber = 4; | ||
5817 | private int specularColorMemoizedSerializedSize; | ||
5818 | private pbc::PopsicleList<float> specularColor_ = new pbc::PopsicleList<float>(); | ||
5819 | public scg::IList<float> SpecularColorList { | ||
5820 | get { return pbc::Lists.AsReadOnly(specularColor_); } | ||
5821 | } | ||
5822 | public int SpecularColorCount { | ||
5823 | get { return specularColor_.Count; } | ||
5824 | } | ||
5825 | public float GetSpecularColor(int index) { | ||
5826 | return specularColor_[index]; | ||
5827 | } | ||
5828 | |||
5829 | public const int PowerFieldNumber = 5; | ||
5830 | private bool hasPower; | ||
5831 | private float power_ = 0F; | ||
5832 | public bool HasPower { | ||
5833 | get { return hasPower; } | ||
5834 | } | ||
5835 | public float Power { | ||
5836 | get { return power_; } | ||
5837 | } | ||
5838 | |||
5839 | public const int AmbientColorFieldNumber = 6; | ||
5840 | private int ambientColorMemoizedSerializedSize; | ||
5841 | private pbc::PopsicleList<float> ambientColor_ = new pbc::PopsicleList<float>(); | ||
5842 | public scg::IList<float> AmbientColorList { | ||
5843 | get { return pbc::Lists.AsReadOnly(ambientColor_); } | ||
5844 | } | ||
5845 | public int AmbientColorCount { | ||
5846 | get { return ambientColor_.Count; } | ||
5847 | } | ||
5848 | public float GetAmbientColor(int index) { | ||
5849 | return ambientColor_[index]; | ||
5850 | } | ||
5851 | |||
5852 | public const int ShadowColorFieldNumber = 7; | ||
5853 | private int shadowColorMemoizedSerializedSize; | ||
5854 | private pbc::PopsicleList<float> shadowColor_ = new pbc::PopsicleList<float>(); | ||
5855 | public scg::IList<float> ShadowColorList { | ||
5856 | get { return pbc::Lists.AsReadOnly(shadowColor_); } | ||
5857 | } | ||
5858 | public int ShadowColorCount { | ||
5859 | get { return shadowColor_.Count; } | ||
5860 | } | ||
5861 | public float GetShadowColor(int index) { | ||
5862 | return shadowColor_[index]; | ||
5863 | } | ||
5864 | |||
5865 | public const int LightRangeFieldNumber = 8; | ||
5866 | private bool hasLightRange; | ||
5867 | private double lightRange_ = 0D; | ||
5868 | public bool HasLightRange { | ||
5869 | get { return hasLightRange; } | ||
5870 | } | ||
5871 | public double LightRange { | ||
5872 | get { return lightRange_; } | ||
5873 | } | ||
5874 | |||
5875 | public const int ConstantFalloffFieldNumber = 9; | ||
5876 | private bool hasConstantFalloff; | ||
5877 | private float constantFalloff_ = 0F; | ||
5878 | public bool HasConstantFalloff { | ||
5879 | get { return hasConstantFalloff; } | ||
5880 | } | ||
5881 | public float ConstantFalloff { | ||
5882 | get { return constantFalloff_; } | ||
5883 | } | ||
5884 | |||
5885 | public const int LinearFalloffFieldNumber = 10; | ||
5886 | private bool hasLinearFalloff; | ||
5887 | private float linearFalloff_ = 0F; | ||
5888 | public bool HasLinearFalloff { | ||
5889 | get { return hasLinearFalloff; } | ||
5890 | } | ||
5891 | public float LinearFalloff { | ||
5892 | get { return linearFalloff_; } | ||
5893 | } | ||
5894 | |||
5895 | public const int QuadraticFalloffFieldNumber = 11; | ||
5896 | private bool hasQuadraticFalloff; | ||
5897 | private float quadraticFalloff_ = 0F; | ||
5898 | public bool HasQuadraticFalloff { | ||
5899 | get { return hasQuadraticFalloff; } | ||
5900 | } | ||
5901 | public float QuadraticFalloff { | ||
5902 | get { return quadraticFalloff_; } | ||
5903 | } | ||
5904 | |||
5905 | public const int ConeInnerRadiansFieldNumber = 12; | ||
5906 | private bool hasConeInnerRadians; | ||
5907 | private float coneInnerRadians_ = 0F; | ||
5908 | public bool HasConeInnerRadians { | ||
5909 | get { return hasConeInnerRadians; } | ||
5910 | } | ||
5911 | public float ConeInnerRadians { | ||
5912 | get { return coneInnerRadians_; } | ||
5913 | } | ||
5914 | |||
5915 | public const int ConeOuterRadiansFieldNumber = 13; | ||
5916 | private bool hasConeOuterRadians; | ||
5917 | private float coneOuterRadians_ = 0F; | ||
5918 | public bool HasConeOuterRadians { | ||
5919 | get { return hasConeOuterRadians; } | ||
5920 | } | ||
5921 | public float ConeOuterRadians { | ||
5922 | get { return coneOuterRadians_; } | ||
5923 | } | ||
5924 | |||
5925 | public const int ConeFalloffFieldNumber = 14; | ||
5926 | private bool hasConeFalloff; | ||
5927 | private float coneFalloff_ = 0F; | ||
5928 | public bool HasConeFalloff { | ||
5929 | get { return hasConeFalloff; } | ||
5930 | } | ||
5931 | public float ConeFalloff { | ||
5932 | get { return coneFalloff_; } | ||
5933 | } | ||
5934 | |||
5935 | public const int TypeFieldNumber = 15; | ||
5936 | private bool hasType; | ||
5937 | private global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes type_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT; | ||
5938 | public bool HasType { | ||
5939 | get { return hasType; } | ||
5940 | } | ||
5941 | public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes Type { | ||
5942 | get { return type_; } | ||
5943 | } | ||
5944 | |||
5945 | public const int CastsShadowFieldNumber = 16; | ||
5946 | private bool hasCastsShadow; | ||
5947 | private bool castsShadow_ = false; | ||
5948 | public bool HasCastsShadow { | ||
5949 | get { return hasCastsShadow; } | ||
5950 | } | ||
5951 | public bool CastsShadow { | ||
5952 | get { return castsShadow_; } | ||
5953 | } | ||
5954 | |||
5955 | public override bool IsInitialized { | ||
5956 | get { | ||
5957 | return true; | ||
5958 | } | ||
5959 | } | ||
5960 | |||
5961 | public override void WriteTo(pb::CodedOutputStream output) { | ||
5962 | if (diffuseColor_.Count > 0) { | ||
5963 | output.WriteRawVarint32(26); | ||
5964 | output.WriteRawVarint32((uint) diffuseColorMemoizedSerializedSize); | ||
5965 | foreach (float element in diffuseColor_) { | ||
5966 | output.WriteFloatNoTag(element); | ||
5967 | } | ||
5968 | } | ||
5969 | if (specularColor_.Count > 0) { | ||
5970 | output.WriteRawVarint32(34); | ||
5971 | output.WriteRawVarint32((uint) specularColorMemoizedSerializedSize); | ||
5972 | foreach (float element in specularColor_) { | ||
5973 | output.WriteFloatNoTag(element); | ||
5974 | } | ||
5975 | } | ||
5976 | if (HasPower) { | ||
5977 | output.WriteFloat(5, Power); | ||
5978 | } | ||
5979 | if (ambientColor_.Count > 0) { | ||
5980 | output.WriteRawVarint32(50); | ||
5981 | output.WriteRawVarint32((uint) ambientColorMemoizedSerializedSize); | ||
5982 | foreach (float element in ambientColor_) { | ||
5983 | output.WriteFloatNoTag(element); | ||
5984 | } | ||
5985 | } | ||
5986 | if (shadowColor_.Count > 0) { | ||
5987 | output.WriteRawVarint32(58); | ||
5988 | output.WriteRawVarint32((uint) shadowColorMemoizedSerializedSize); | ||
5989 | foreach (float element in shadowColor_) { | ||
5990 | output.WriteFloatNoTag(element); | ||
5991 | } | ||
5992 | } | ||
5993 | if (HasLightRange) { | ||
5994 | output.WriteDouble(8, LightRange); | ||
5995 | } | ||
5996 | if (HasConstantFalloff) { | ||
5997 | output.WriteFloat(9, ConstantFalloff); | ||
5998 | } | ||
5999 | if (HasLinearFalloff) { | ||
6000 | output.WriteFloat(10, LinearFalloff); | ||
6001 | } | ||
6002 | if (HasQuadraticFalloff) { | ||
6003 | output.WriteFloat(11, QuadraticFalloff); | ||
6004 | } | ||
6005 | if (HasConeInnerRadians) { | ||
6006 | output.WriteFloat(12, ConeInnerRadians); | ||
6007 | } | ||
6008 | if (HasConeOuterRadians) { | ||
6009 | output.WriteFloat(13, ConeOuterRadians); | ||
6010 | } | ||
6011 | if (HasConeFalloff) { | ||
6012 | output.WriteFloat(14, ConeFalloff); | ||
6013 | } | ||
6014 | if (HasType) { | ||
6015 | output.WriteEnum(15, (int) Type); | ||
6016 | } | ||
6017 | if (HasCastsShadow) { | ||
6018 | output.WriteBool(16, CastsShadow); | ||
6019 | } | ||
6020 | UnknownFields.WriteTo(output); | ||
6021 | } | ||
6022 | |||
6023 | private int memoizedSerializedSize = -1; | ||
6024 | public override int SerializedSize { | ||
6025 | get { | ||
6026 | int size = memoizedSerializedSize; | ||
6027 | if (size != -1) return size; | ||
6028 | |||
6029 | size = 0; | ||
6030 | { | ||
6031 | int dataSize = 0; | ||
6032 | dataSize = 4 * diffuseColor_.Count; | ||
6033 | size += dataSize; | ||
6034 | if (diffuseColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
6035 | diffuseColorMemoizedSerializedSize = dataSize; | ||
6036 | } | ||
6037 | { | ||
6038 | int dataSize = 0; | ||
6039 | dataSize = 4 * specularColor_.Count; | ||
6040 | size += dataSize; | ||
6041 | if (specularColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
6042 | specularColorMemoizedSerializedSize = dataSize; | ||
6043 | } | ||
6044 | if (HasPower) { | ||
6045 | size += pb::CodedOutputStream.ComputeFloatSize(5, Power); | ||
6046 | } | ||
6047 | { | ||
6048 | int dataSize = 0; | ||
6049 | dataSize = 4 * ambientColor_.Count; | ||
6050 | size += dataSize; | ||
6051 | if (ambientColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
6052 | ambientColorMemoizedSerializedSize = dataSize; | ||
6053 | } | ||
6054 | { | ||
6055 | int dataSize = 0; | ||
6056 | dataSize = 4 * shadowColor_.Count; | ||
6057 | size += dataSize; | ||
6058 | if (shadowColor_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
6059 | shadowColorMemoizedSerializedSize = dataSize; | ||
6060 | } | ||
6061 | if (HasLightRange) { | ||
6062 | size += pb::CodedOutputStream.ComputeDoubleSize(8, LightRange); | ||
6063 | } | ||
6064 | if (HasConstantFalloff) { | ||
6065 | size += pb::CodedOutputStream.ComputeFloatSize(9, ConstantFalloff); | ||
6066 | } | ||
6067 | if (HasLinearFalloff) { | ||
6068 | size += pb::CodedOutputStream.ComputeFloatSize(10, LinearFalloff); | ||
6069 | } | ||
6070 | if (HasQuadraticFalloff) { | ||
6071 | size += pb::CodedOutputStream.ComputeFloatSize(11, QuadraticFalloff); | ||
6072 | } | ||
6073 | if (HasConeInnerRadians) { | ||
6074 | size += pb::CodedOutputStream.ComputeFloatSize(12, ConeInnerRadians); | ||
6075 | } | ||
6076 | if (HasConeOuterRadians) { | ||
6077 | size += pb::CodedOutputStream.ComputeFloatSize(13, ConeOuterRadians); | ||
6078 | } | ||
6079 | if (HasConeFalloff) { | ||
6080 | size += pb::CodedOutputStream.ComputeFloatSize(14, ConeFalloff); | ||
6081 | } | ||
6082 | if (HasType) { | ||
6083 | size += pb::CodedOutputStream.ComputeEnumSize(15, (int) Type); | ||
6084 | } | ||
6085 | if (HasCastsShadow) { | ||
6086 | size += pb::CodedOutputStream.ComputeBoolSize(16, CastsShadow); | ||
6087 | } | ||
6088 | size += UnknownFields.SerializedSize; | ||
6089 | memoizedSerializedSize = size; | ||
6090 | return size; | ||
6091 | } | ||
6092 | } | ||
6093 | |||
6094 | public static LightInfoProperty ParseFrom(pb::ByteString data) { | ||
6095 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
6096 | } | ||
6097 | public static LightInfoProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
6098 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
6099 | } | ||
6100 | public static LightInfoProperty ParseFrom(byte[] data) { | ||
6101 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
6102 | } | ||
6103 | public static LightInfoProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
6104 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
6105 | } | ||
6106 | public static LightInfoProperty ParseFrom(global::System.IO.Stream input) { | ||
6107 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
6108 | } | ||
6109 | public static LightInfoProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
6110 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
6111 | } | ||
6112 | public static LightInfoProperty ParseDelimitedFrom(global::System.IO.Stream input) { | ||
6113 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
6114 | } | ||
6115 | public static LightInfoProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
6116 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
6117 | } | ||
6118 | public static LightInfoProperty ParseFrom(pb::CodedInputStream input) { | ||
6119 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
6120 | } | ||
6121 | public static LightInfoProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
6122 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
6123 | } | ||
6124 | public static Builder CreateBuilder() { return new Builder(); } | ||
6125 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
6126 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
6127 | public static Builder CreateBuilder(LightInfoProperty prototype) { | ||
6128 | return (Builder) new Builder().MergeFrom(prototype); | ||
6129 | } | ||
6130 | |||
6131 | public sealed partial class Builder : pb::GeneratedBuilder<LightInfoProperty, Builder> { | ||
6132 | protected override Builder ThisBuilder { | ||
6133 | get { return this; } | ||
6134 | } | ||
6135 | public Builder() {} | ||
6136 | |||
6137 | LightInfoProperty result = new LightInfoProperty(); | ||
6138 | |||
6139 | protected override LightInfoProperty MessageBeingBuilt { | ||
6140 | get { return result; } | ||
6141 | } | ||
6142 | |||
6143 | public override Builder Clear() { | ||
6144 | result = new LightInfoProperty(); | ||
6145 | return this; | ||
6146 | } | ||
6147 | |||
6148 | public override Builder Clone() { | ||
6149 | return new Builder().MergeFrom(result); | ||
6150 | } | ||
6151 | |||
6152 | public override pbd::MessageDescriptor DescriptorForType { | ||
6153 | get { return global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Descriptor; } | ||
6154 | } | ||
6155 | |||
6156 | public override LightInfoProperty DefaultInstanceForType { | ||
6157 | get { return global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; } | ||
6158 | } | ||
6159 | |||
6160 | public override LightInfoProperty BuildPartial() { | ||
6161 | if (result == null) { | ||
6162 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
6163 | } | ||
6164 | result.diffuseColor_.MakeReadOnly(); | ||
6165 | result.specularColor_.MakeReadOnly(); | ||
6166 | result.ambientColor_.MakeReadOnly(); | ||
6167 | result.shadowColor_.MakeReadOnly(); | ||
6168 | LightInfoProperty returnMe = result; | ||
6169 | result = null; | ||
6170 | return returnMe; | ||
6171 | } | ||
6172 | |||
6173 | public override Builder MergeFrom(pb::IMessage other) { | ||
6174 | if (other is LightInfoProperty) { | ||
6175 | return MergeFrom((LightInfoProperty) other); | ||
6176 | } else { | ||
6177 | base.MergeFrom(other); | ||
6178 | return this; | ||
6179 | } | ||
6180 | } | ||
6181 | |||
6182 | public override Builder MergeFrom(LightInfoProperty other) { | ||
6183 | if (other == global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance) return this; | ||
6184 | if (other.diffuseColor_.Count != 0) { | ||
6185 | base.AddRange(other.diffuseColor_, result.diffuseColor_); | ||
6186 | } | ||
6187 | if (other.specularColor_.Count != 0) { | ||
6188 | base.AddRange(other.specularColor_, result.specularColor_); | ||
6189 | } | ||
6190 | if (other.HasPower) { | ||
6191 | Power = other.Power; | ||
6192 | } | ||
6193 | if (other.ambientColor_.Count != 0) { | ||
6194 | base.AddRange(other.ambientColor_, result.ambientColor_); | ||
6195 | } | ||
6196 | if (other.shadowColor_.Count != 0) { | ||
6197 | base.AddRange(other.shadowColor_, result.shadowColor_); | ||
6198 | } | ||
6199 | if (other.HasLightRange) { | ||
6200 | LightRange = other.LightRange; | ||
6201 | } | ||
6202 | if (other.HasConstantFalloff) { | ||
6203 | ConstantFalloff = other.ConstantFalloff; | ||
6204 | } | ||
6205 | if (other.HasLinearFalloff) { | ||
6206 | LinearFalloff = other.LinearFalloff; | ||
6207 | } | ||
6208 | if (other.HasQuadraticFalloff) { | ||
6209 | QuadraticFalloff = other.QuadraticFalloff; | ||
6210 | } | ||
6211 | if (other.HasConeInnerRadians) { | ||
6212 | ConeInnerRadians = other.ConeInnerRadians; | ||
6213 | } | ||
6214 | if (other.HasConeOuterRadians) { | ||
6215 | ConeOuterRadians = other.ConeOuterRadians; | ||
6216 | } | ||
6217 | if (other.HasConeFalloff) { | ||
6218 | ConeFalloff = other.ConeFalloff; | ||
6219 | } | ||
6220 | if (other.HasType) { | ||
6221 | Type = other.Type; | ||
6222 | } | ||
6223 | if (other.HasCastsShadow) { | ||
6224 | CastsShadow = other.CastsShadow; | ||
6225 | } | ||
6226 | this.MergeUnknownFields(other.UnknownFields); | ||
6227 | return this; | ||
6228 | } | ||
6229 | |||
6230 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
6231 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
6232 | } | ||
6233 | |||
6234 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
6235 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
6236 | while (true) { | ||
6237 | uint tag = input.ReadTag(); | ||
6238 | switch (tag) { | ||
6239 | case 0: { | ||
6240 | if (unknownFields != null) { | ||
6241 | this.UnknownFields = unknownFields.Build(); | ||
6242 | } | ||
6243 | return this; | ||
6244 | } | ||
6245 | default: { | ||
6246 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
6247 | if (unknownFields != null) { | ||
6248 | this.UnknownFields = unknownFields.Build(); | ||
6249 | } | ||
6250 | return this; | ||
6251 | } | ||
6252 | if (unknownFields == null) { | ||
6253 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
6254 | } | ||
6255 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
6256 | break; | ||
6257 | } | ||
6258 | case 26: { | ||
6259 | int length = input.ReadInt32(); | ||
6260 | int limit = input.PushLimit(length); | ||
6261 | while (!input.ReachedLimit) { | ||
6262 | AddDiffuseColor(input.ReadFloat()); | ||
6263 | } | ||
6264 | input.PopLimit(limit); | ||
6265 | break; | ||
6266 | } | ||
6267 | case 34: { | ||
6268 | int length = input.ReadInt32(); | ||
6269 | int limit = input.PushLimit(length); | ||
6270 | while (!input.ReachedLimit) { | ||
6271 | AddSpecularColor(input.ReadFloat()); | ||
6272 | } | ||
6273 | input.PopLimit(limit); | ||
6274 | break; | ||
6275 | } | ||
6276 | case 45: { | ||
6277 | Power = input.ReadFloat(); | ||
6278 | break; | ||
6279 | } | ||
6280 | case 50: { | ||
6281 | int length = input.ReadInt32(); | ||
6282 | int limit = input.PushLimit(length); | ||
6283 | while (!input.ReachedLimit) { | ||
6284 | AddAmbientColor(input.ReadFloat()); | ||
6285 | } | ||
6286 | input.PopLimit(limit); | ||
6287 | break; | ||
6288 | } | ||
6289 | case 58: { | ||
6290 | int length = input.ReadInt32(); | ||
6291 | int limit = input.PushLimit(length); | ||
6292 | while (!input.ReachedLimit) { | ||
6293 | AddShadowColor(input.ReadFloat()); | ||
6294 | } | ||
6295 | input.PopLimit(limit); | ||
6296 | break; | ||
6297 | } | ||
6298 | case 65: { | ||
6299 | LightRange = input.ReadDouble(); | ||
6300 | break; | ||
6301 | } | ||
6302 | case 77: { | ||
6303 | ConstantFalloff = input.ReadFloat(); | ||
6304 | break; | ||
6305 | } | ||
6306 | case 85: { | ||
6307 | LinearFalloff = input.ReadFloat(); | ||
6308 | break; | ||
6309 | } | ||
6310 | case 93: { | ||
6311 | QuadraticFalloff = input.ReadFloat(); | ||
6312 | break; | ||
6313 | } | ||
6314 | case 101: { | ||
6315 | ConeInnerRadians = input.ReadFloat(); | ||
6316 | break; | ||
6317 | } | ||
6318 | case 109: { | ||
6319 | ConeOuterRadians = input.ReadFloat(); | ||
6320 | break; | ||
6321 | } | ||
6322 | case 117: { | ||
6323 | ConeFalloff = input.ReadFloat(); | ||
6324 | break; | ||
6325 | } | ||
6326 | case 120: { | ||
6327 | int rawValue = input.ReadEnum(); | ||
6328 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes), rawValue)) { | ||
6329 | if (unknownFields == null) { | ||
6330 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
6331 | } | ||
6332 | unknownFields.MergeVarintField(15, (ulong) rawValue); | ||
6333 | } else { | ||
6334 | Type = (global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes) rawValue; | ||
6335 | } | ||
6336 | break; | ||
6337 | } | ||
6338 | case 128: { | ||
6339 | CastsShadow = input.ReadBool(); | ||
6340 | break; | ||
6341 | } | ||
6342 | } | ||
6343 | } | ||
6344 | } | ||
6345 | |||
6346 | |||
6347 | public pbc::IPopsicleList<float> DiffuseColorList { | ||
6348 | get { return result.diffuseColor_; } | ||
6349 | } | ||
6350 | public int DiffuseColorCount { | ||
6351 | get { return result.DiffuseColorCount; } | ||
6352 | } | ||
6353 | public float GetDiffuseColor(int index) { | ||
6354 | return result.GetDiffuseColor(index); | ||
6355 | } | ||
6356 | public Builder SetDiffuseColor(int index, float value) { | ||
6357 | result.diffuseColor_[index] = value; | ||
6358 | return this; | ||
6359 | } | ||
6360 | public Builder AddDiffuseColor(float value) { | ||
6361 | result.diffuseColor_.Add(value); | ||
6362 | return this; | ||
6363 | } | ||
6364 | public Builder AddRangeDiffuseColor(scg::IEnumerable<float> values) { | ||
6365 | base.AddRange(values, result.diffuseColor_); | ||
6366 | return this; | ||
6367 | } | ||
6368 | public Builder ClearDiffuseColor() { | ||
6369 | result.diffuseColor_.Clear(); | ||
6370 | return this; | ||
6371 | } | ||
6372 | |||
6373 | public pbc::IPopsicleList<float> SpecularColorList { | ||
6374 | get { return result.specularColor_; } | ||
6375 | } | ||
6376 | public int SpecularColorCount { | ||
6377 | get { return result.SpecularColorCount; } | ||
6378 | } | ||
6379 | public float GetSpecularColor(int index) { | ||
6380 | return result.GetSpecularColor(index); | ||
6381 | } | ||
6382 | public Builder SetSpecularColor(int index, float value) { | ||
6383 | result.specularColor_[index] = value; | ||
6384 | return this; | ||
6385 | } | ||
6386 | public Builder AddSpecularColor(float value) { | ||
6387 | result.specularColor_.Add(value); | ||
6388 | return this; | ||
6389 | } | ||
6390 | public Builder AddRangeSpecularColor(scg::IEnumerable<float> values) { | ||
6391 | base.AddRange(values, result.specularColor_); | ||
6392 | return this; | ||
6393 | } | ||
6394 | public Builder ClearSpecularColor() { | ||
6395 | result.specularColor_.Clear(); | ||
6396 | return this; | ||
6397 | } | ||
6398 | |||
6399 | public bool HasPower { | ||
6400 | get { return result.HasPower; } | ||
6401 | } | ||
6402 | public float Power { | ||
6403 | get { return result.Power; } | ||
6404 | set { SetPower(value); } | ||
6405 | } | ||
6406 | public Builder SetPower(float value) { | ||
6407 | result.hasPower = true; | ||
6408 | result.power_ = value; | ||
6409 | return this; | ||
6410 | } | ||
6411 | public Builder ClearPower() { | ||
6412 | result.hasPower = false; | ||
6413 | result.power_ = 0F; | ||
6414 | return this; | ||
6415 | } | ||
6416 | |||
6417 | public pbc::IPopsicleList<float> AmbientColorList { | ||
6418 | get { return result.ambientColor_; } | ||
6419 | } | ||
6420 | public int AmbientColorCount { | ||
6421 | get { return result.AmbientColorCount; } | ||
6422 | } | ||
6423 | public float GetAmbientColor(int index) { | ||
6424 | return result.GetAmbientColor(index); | ||
6425 | } | ||
6426 | public Builder SetAmbientColor(int index, float value) { | ||
6427 | result.ambientColor_[index] = value; | ||
6428 | return this; | ||
6429 | } | ||
6430 | public Builder AddAmbientColor(float value) { | ||
6431 | result.ambientColor_.Add(value); | ||
6432 | return this; | ||
6433 | } | ||
6434 | public Builder AddRangeAmbientColor(scg::IEnumerable<float> values) { | ||
6435 | base.AddRange(values, result.ambientColor_); | ||
6436 | return this; | ||
6437 | } | ||
6438 | public Builder ClearAmbientColor() { | ||
6439 | result.ambientColor_.Clear(); | ||
6440 | return this; | ||
6441 | } | ||
6442 | |||
6443 | public pbc::IPopsicleList<float> ShadowColorList { | ||
6444 | get { return result.shadowColor_; } | ||
6445 | } | ||
6446 | public int ShadowColorCount { | ||
6447 | get { return result.ShadowColorCount; } | ||
6448 | } | ||
6449 | public float GetShadowColor(int index) { | ||
6450 | return result.GetShadowColor(index); | ||
6451 | } | ||
6452 | public Builder SetShadowColor(int index, float value) { | ||
6453 | result.shadowColor_[index] = value; | ||
6454 | return this; | ||
6455 | } | ||
6456 | public Builder AddShadowColor(float value) { | ||
6457 | result.shadowColor_.Add(value); | ||
6458 | return this; | ||
6459 | } | ||
6460 | public Builder AddRangeShadowColor(scg::IEnumerable<float> values) { | ||
6461 | base.AddRange(values, result.shadowColor_); | ||
6462 | return this; | ||
6463 | } | ||
6464 | public Builder ClearShadowColor() { | ||
6465 | result.shadowColor_.Clear(); | ||
6466 | return this; | ||
6467 | } | ||
6468 | |||
6469 | public bool HasLightRange { | ||
6470 | get { return result.HasLightRange; } | ||
6471 | } | ||
6472 | public double LightRange { | ||
6473 | get { return result.LightRange; } | ||
6474 | set { SetLightRange(value); } | ||
6475 | } | ||
6476 | public Builder SetLightRange(double value) { | ||
6477 | result.hasLightRange = true; | ||
6478 | result.lightRange_ = value; | ||
6479 | return this; | ||
6480 | } | ||
6481 | public Builder ClearLightRange() { | ||
6482 | result.hasLightRange = false; | ||
6483 | result.lightRange_ = 0D; | ||
6484 | return this; | ||
6485 | } | ||
6486 | |||
6487 | public bool HasConstantFalloff { | ||
6488 | get { return result.HasConstantFalloff; } | ||
6489 | } | ||
6490 | public float ConstantFalloff { | ||
6491 | get { return result.ConstantFalloff; } | ||
6492 | set { SetConstantFalloff(value); } | ||
6493 | } | ||
6494 | public Builder SetConstantFalloff(float value) { | ||
6495 | result.hasConstantFalloff = true; | ||
6496 | result.constantFalloff_ = value; | ||
6497 | return this; | ||
6498 | } | ||
6499 | public Builder ClearConstantFalloff() { | ||
6500 | result.hasConstantFalloff = false; | ||
6501 | result.constantFalloff_ = 0F; | ||
6502 | return this; | ||
6503 | } | ||
6504 | |||
6505 | public bool HasLinearFalloff { | ||
6506 | get { return result.HasLinearFalloff; } | ||
6507 | } | ||
6508 | public float LinearFalloff { | ||
6509 | get { return result.LinearFalloff; } | ||
6510 | set { SetLinearFalloff(value); } | ||
6511 | } | ||
6512 | public Builder SetLinearFalloff(float value) { | ||
6513 | result.hasLinearFalloff = true; | ||
6514 | result.linearFalloff_ = value; | ||
6515 | return this; | ||
6516 | } | ||
6517 | public Builder ClearLinearFalloff() { | ||
6518 | result.hasLinearFalloff = false; | ||
6519 | result.linearFalloff_ = 0F; | ||
6520 | return this; | ||
6521 | } | ||
6522 | |||
6523 | public bool HasQuadraticFalloff { | ||
6524 | get { return result.HasQuadraticFalloff; } | ||
6525 | } | ||
6526 | public float QuadraticFalloff { | ||
6527 | get { return result.QuadraticFalloff; } | ||
6528 | set { SetQuadraticFalloff(value); } | ||
6529 | } | ||
6530 | public Builder SetQuadraticFalloff(float value) { | ||
6531 | result.hasQuadraticFalloff = true; | ||
6532 | result.quadraticFalloff_ = value; | ||
6533 | return this; | ||
6534 | } | ||
6535 | public Builder ClearQuadraticFalloff() { | ||
6536 | result.hasQuadraticFalloff = false; | ||
6537 | result.quadraticFalloff_ = 0F; | ||
6538 | return this; | ||
6539 | } | ||
6540 | |||
6541 | public bool HasConeInnerRadians { | ||
6542 | get { return result.HasConeInnerRadians; } | ||
6543 | } | ||
6544 | public float ConeInnerRadians { | ||
6545 | get { return result.ConeInnerRadians; } | ||
6546 | set { SetConeInnerRadians(value); } | ||
6547 | } | ||
6548 | public Builder SetConeInnerRadians(float value) { | ||
6549 | result.hasConeInnerRadians = true; | ||
6550 | result.coneInnerRadians_ = value; | ||
6551 | return this; | ||
6552 | } | ||
6553 | public Builder ClearConeInnerRadians() { | ||
6554 | result.hasConeInnerRadians = false; | ||
6555 | result.coneInnerRadians_ = 0F; | ||
6556 | return this; | ||
6557 | } | ||
6558 | |||
6559 | public bool HasConeOuterRadians { | ||
6560 | get { return result.HasConeOuterRadians; } | ||
6561 | } | ||
6562 | public float ConeOuterRadians { | ||
6563 | get { return result.ConeOuterRadians; } | ||
6564 | set { SetConeOuterRadians(value); } | ||
6565 | } | ||
6566 | public Builder SetConeOuterRadians(float value) { | ||
6567 | result.hasConeOuterRadians = true; | ||
6568 | result.coneOuterRadians_ = value; | ||
6569 | return this; | ||
6570 | } | ||
6571 | public Builder ClearConeOuterRadians() { | ||
6572 | result.hasConeOuterRadians = false; | ||
6573 | result.coneOuterRadians_ = 0F; | ||
6574 | return this; | ||
6575 | } | ||
6576 | |||
6577 | public bool HasConeFalloff { | ||
6578 | get { return result.HasConeFalloff; } | ||
6579 | } | ||
6580 | public float ConeFalloff { | ||
6581 | get { return result.ConeFalloff; } | ||
6582 | set { SetConeFalloff(value); } | ||
6583 | } | ||
6584 | public Builder SetConeFalloff(float value) { | ||
6585 | result.hasConeFalloff = true; | ||
6586 | result.coneFalloff_ = value; | ||
6587 | return this; | ||
6588 | } | ||
6589 | public Builder ClearConeFalloff() { | ||
6590 | result.hasConeFalloff = false; | ||
6591 | result.coneFalloff_ = 0F; | ||
6592 | return this; | ||
6593 | } | ||
6594 | |||
6595 | public bool HasType { | ||
6596 | get { return result.HasType; } | ||
6597 | } | ||
6598 | public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes Type { | ||
6599 | get { return result.Type; } | ||
6600 | set { SetType(value); } | ||
6601 | } | ||
6602 | public Builder SetType(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes value) { | ||
6603 | result.hasType = true; | ||
6604 | result.type_ = value; | ||
6605 | return this; | ||
6606 | } | ||
6607 | public Builder ClearType() { | ||
6608 | result.hasType = false; | ||
6609 | result.type_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT; | ||
6610 | return this; | ||
6611 | } | ||
6612 | |||
6613 | public bool HasCastsShadow { | ||
6614 | get { return result.HasCastsShadow; } | ||
6615 | } | ||
6616 | public bool CastsShadow { | ||
6617 | get { return result.CastsShadow; } | ||
6618 | set { SetCastsShadow(value); } | ||
6619 | } | ||
6620 | public Builder SetCastsShadow(bool value) { | ||
6621 | result.hasCastsShadow = true; | ||
6622 | result.castsShadow_ = value; | ||
6623 | return this; | ||
6624 | } | ||
6625 | public Builder ClearCastsShadow() { | ||
6626 | result.hasCastsShadow = false; | ||
6627 | result.castsShadow_ = false; | ||
6628 | return this; | ||
6629 | } | ||
6630 | } | ||
6631 | static LightInfoProperty() { | ||
6632 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
6633 | } | ||
6634 | } | ||
6635 | |||
6636 | public sealed partial class ParentProperty : pb::GeneratedMessage<ParentProperty, ParentProperty.Builder> { | ||
6637 | private static readonly ParentProperty defaultInstance = new Builder().BuildPartial(); | ||
6638 | public static ParentProperty DefaultInstance { | ||
6639 | get { return defaultInstance; } | ||
6640 | } | ||
6641 | |||
6642 | public override ParentProperty DefaultInstanceForType { | ||
6643 | get { return defaultInstance; } | ||
6644 | } | ||
6645 | |||
6646 | protected override ParentProperty ThisMessage { | ||
6647 | get { return this; } | ||
6648 | } | ||
6649 | |||
6650 | public static pbd::MessageDescriptor Descriptor { | ||
6651 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__Descriptor; } | ||
6652 | } | ||
6653 | |||
6654 | protected override pb::FieldAccess.FieldAccessorTable<ParentProperty, ParentProperty.Builder> InternalFieldAccessors { | ||
6655 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ParentProperty__FieldAccessorTable; } | ||
6656 | } | ||
6657 | |||
6658 | public const int ValueFieldNumber = 10; | ||
6659 | private bool hasValue; | ||
6660 | private pb::ByteString value_ = pb::ByteString.Empty; | ||
6661 | public bool HasValue { | ||
6662 | get { return hasValue; } | ||
6663 | } | ||
6664 | public pb::ByteString Value { | ||
6665 | get { return value_; } | ||
6666 | } | ||
6667 | |||
6668 | public override bool IsInitialized { | ||
6669 | get { | ||
6670 | return true; | ||
6671 | } | ||
6672 | } | ||
6673 | |||
6674 | public override void WriteTo(pb::CodedOutputStream output) { | ||
6675 | if (HasValue) { | ||
6676 | output.WriteBytes(10, Value); | ||
6677 | } | ||
6678 | UnknownFields.WriteTo(output); | ||
6679 | } | ||
6680 | |||
6681 | private int memoizedSerializedSize = -1; | ||
6682 | public override int SerializedSize { | ||
6683 | get { | ||
6684 | int size = memoizedSerializedSize; | ||
6685 | if (size != -1) return size; | ||
6686 | |||
6687 | size = 0; | ||
6688 | if (HasValue) { | ||
6689 | size += pb::CodedOutputStream.ComputeBytesSize(10, Value); | ||
6690 | } | ||
6691 | size += UnknownFields.SerializedSize; | ||
6692 | memoizedSerializedSize = size; | ||
6693 | return size; | ||
6694 | } | ||
6695 | } | ||
6696 | |||
6697 | public static ParentProperty ParseFrom(pb::ByteString data) { | ||
6698 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
6699 | } | ||
6700 | public static ParentProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
6701 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
6702 | } | ||
6703 | public static ParentProperty ParseFrom(byte[] data) { | ||
6704 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
6705 | } | ||
6706 | public static ParentProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
6707 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
6708 | } | ||
6709 | public static ParentProperty ParseFrom(global::System.IO.Stream input) { | ||
6710 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
6711 | } | ||
6712 | public static ParentProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
6713 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
6714 | } | ||
6715 | public static ParentProperty ParseDelimitedFrom(global::System.IO.Stream input) { | ||
6716 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
6717 | } | ||
6718 | public static ParentProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
6719 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
6720 | } | ||
6721 | public static ParentProperty ParseFrom(pb::CodedInputStream input) { | ||
6722 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
6723 | } | ||
6724 | public static ParentProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
6725 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
6726 | } | ||
6727 | public static Builder CreateBuilder() { return new Builder(); } | ||
6728 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
6729 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
6730 | public static Builder CreateBuilder(ParentProperty prototype) { | ||
6731 | return (Builder) new Builder().MergeFrom(prototype); | ||
6732 | } | ||
6733 | |||
6734 | public sealed partial class Builder : pb::GeneratedBuilder<ParentProperty, Builder> { | ||
6735 | protected override Builder ThisBuilder { | ||
6736 | get { return this; } | ||
6737 | } | ||
6738 | public Builder() {} | ||
6739 | |||
6740 | ParentProperty result = new ParentProperty(); | ||
6741 | |||
6742 | protected override ParentProperty MessageBeingBuilt { | ||
6743 | get { return result; } | ||
6744 | } | ||
6745 | |||
6746 | public override Builder Clear() { | ||
6747 | result = new ParentProperty(); | ||
6748 | return this; | ||
6749 | } | ||
6750 | |||
6751 | public override Builder Clone() { | ||
6752 | return new Builder().MergeFrom(result); | ||
6753 | } | ||
6754 | |||
6755 | public override pbd::MessageDescriptor DescriptorForType { | ||
6756 | get { return global::Sirikata.Protocol._PBJ_Internal.ParentProperty.Descriptor; } | ||
6757 | } | ||
6758 | |||
6759 | public override ParentProperty DefaultInstanceForType { | ||
6760 | get { return global::Sirikata.Protocol._PBJ_Internal.ParentProperty.DefaultInstance; } | ||
6761 | } | ||
6762 | |||
6763 | public override ParentProperty BuildPartial() { | ||
6764 | if (result == null) { | ||
6765 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
6766 | } | ||
6767 | ParentProperty returnMe = result; | ||
6768 | result = null; | ||
6769 | return returnMe; | ||
6770 | } | ||
6771 | |||
6772 | public override Builder MergeFrom(pb::IMessage other) { | ||
6773 | if (other is ParentProperty) { | ||
6774 | return MergeFrom((ParentProperty) other); | ||
6775 | } else { | ||
6776 | base.MergeFrom(other); | ||
6777 | return this; | ||
6778 | } | ||
6779 | } | ||
6780 | |||
6781 | public override Builder MergeFrom(ParentProperty other) { | ||
6782 | if (other == global::Sirikata.Protocol._PBJ_Internal.ParentProperty.DefaultInstance) return this; | ||
6783 | if (other.HasValue) { | ||
6784 | Value = other.Value; | ||
6785 | } | ||
6786 | this.MergeUnknownFields(other.UnknownFields); | ||
6787 | return this; | ||
6788 | } | ||
6789 | |||
6790 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
6791 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
6792 | } | ||
6793 | |||
6794 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
6795 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
6796 | while (true) { | ||
6797 | uint tag = input.ReadTag(); | ||
6798 | switch (tag) { | ||
6799 | case 0: { | ||
6800 | if (unknownFields != null) { | ||
6801 | this.UnknownFields = unknownFields.Build(); | ||
6802 | } | ||
6803 | return this; | ||
6804 | } | ||
6805 | default: { | ||
6806 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
6807 | if (unknownFields != null) { | ||
6808 | this.UnknownFields = unknownFields.Build(); | ||
6809 | } | ||
6810 | return this; | ||
6811 | } | ||
6812 | if (unknownFields == null) { | ||
6813 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
6814 | } | ||
6815 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
6816 | break; | ||
6817 | } | ||
6818 | case 82: { | ||
6819 | Value = input.ReadBytes(); | ||
6820 | break; | ||
6821 | } | ||
6822 | } | ||
6823 | } | ||
6824 | } | ||
6825 | |||
6826 | |||
6827 | public bool HasValue { | ||
6828 | get { return result.HasValue; } | ||
6829 | } | ||
6830 | public pb::ByteString Value { | ||
6831 | get { return result.Value; } | ||
6832 | set { SetValue(value); } | ||
6833 | } | ||
6834 | public Builder SetValue(pb::ByteString value) { | ||
6835 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
6836 | result.hasValue = true; | ||
6837 | result.value_ = value; | ||
6838 | return this; | ||
6839 | } | ||
6840 | public Builder ClearValue() { | ||
6841 | result.hasValue = false; | ||
6842 | result.value_ = pb::ByteString.Empty; | ||
6843 | return this; | ||
6844 | } | ||
6845 | } | ||
6846 | static ParentProperty() { | ||
6847 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
6848 | } | ||
6849 | } | ||
6850 | |||
6851 | public sealed partial class UUIDListProperty : pb::GeneratedMessage<UUIDListProperty, UUIDListProperty.Builder> { | ||
6852 | private static readonly UUIDListProperty defaultInstance = new Builder().BuildPartial(); | ||
6853 | public static UUIDListProperty DefaultInstance { | ||
6854 | get { return defaultInstance; } | ||
6855 | } | ||
6856 | |||
6857 | public override UUIDListProperty DefaultInstanceForType { | ||
6858 | get { return defaultInstance; } | ||
6859 | } | ||
6860 | |||
6861 | protected override UUIDListProperty ThisMessage { | ||
6862 | get { return this; } | ||
6863 | } | ||
6864 | |||
6865 | public static pbd::MessageDescriptor Descriptor { | ||
6866 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__Descriptor; } | ||
6867 | } | ||
6868 | |||
6869 | protected override pb::FieldAccess.FieldAccessorTable<UUIDListProperty, UUIDListProperty.Builder> InternalFieldAccessors { | ||
6870 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_UUIDListProperty__FieldAccessorTable; } | ||
6871 | } | ||
6872 | |||
6873 | public const int ValueFieldNumber = 10; | ||
6874 | private pbc::PopsicleList<pb::ByteString> value_ = new pbc::PopsicleList<pb::ByteString>(); | ||
6875 | public scg::IList<pb::ByteString> ValueList { | ||
6876 | get { return pbc::Lists.AsReadOnly(value_); } | ||
6877 | } | ||
6878 | public int ValueCount { | ||
6879 | get { return value_.Count; } | ||
6880 | } | ||
6881 | public pb::ByteString GetValue(int index) { | ||
6882 | return value_[index]; | ||
6883 | } | ||
6884 | |||
6885 | public override bool IsInitialized { | ||
6886 | get { | ||
6887 | return true; | ||
6888 | } | ||
6889 | } | ||
6890 | |||
6891 | public override void WriteTo(pb::CodedOutputStream output) { | ||
6892 | if (value_.Count > 0) { | ||
6893 | foreach (pb::ByteString element in value_) { | ||
6894 | output.WriteBytes(10, element); | ||
6895 | } | ||
6896 | } | ||
6897 | UnknownFields.WriteTo(output); | ||
6898 | } | ||
6899 | |||
6900 | private int memoizedSerializedSize = -1; | ||
6901 | public override int SerializedSize { | ||
6902 | get { | ||
6903 | int size = memoizedSerializedSize; | ||
6904 | if (size != -1) return size; | ||
6905 | |||
6906 | size = 0; | ||
6907 | { | ||
6908 | int dataSize = 0; | ||
6909 | foreach (pb::ByteString element in ValueList) { | ||
6910 | dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); | ||
6911 | } | ||
6912 | size += dataSize; | ||
6913 | size += 1 * value_.Count; | ||
6914 | } | ||
6915 | size += UnknownFields.SerializedSize; | ||
6916 | memoizedSerializedSize = size; | ||
6917 | return size; | ||
6918 | } | ||
6919 | } | ||
6920 | |||
6921 | public static UUIDListProperty ParseFrom(pb::ByteString data) { | ||
6922 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
6923 | } | ||
6924 | public static UUIDListProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
6925 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
6926 | } | ||
6927 | public static UUIDListProperty ParseFrom(byte[] data) { | ||
6928 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
6929 | } | ||
6930 | public static UUIDListProperty ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
6931 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
6932 | } | ||
6933 | public static UUIDListProperty ParseFrom(global::System.IO.Stream input) { | ||
6934 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
6935 | } | ||
6936 | public static UUIDListProperty ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
6937 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
6938 | } | ||
6939 | public static UUIDListProperty ParseDelimitedFrom(global::System.IO.Stream input) { | ||
6940 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
6941 | } | ||
6942 | public static UUIDListProperty ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
6943 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
6944 | } | ||
6945 | public static UUIDListProperty ParseFrom(pb::CodedInputStream input) { | ||
6946 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
6947 | } | ||
6948 | public static UUIDListProperty ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
6949 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
6950 | } | ||
6951 | public static Builder CreateBuilder() { return new Builder(); } | ||
6952 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
6953 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
6954 | public static Builder CreateBuilder(UUIDListProperty prototype) { | ||
6955 | return (Builder) new Builder().MergeFrom(prototype); | ||
6956 | } | ||
6957 | |||
6958 | public sealed partial class Builder : pb::GeneratedBuilder<UUIDListProperty, Builder> { | ||
6959 | protected override Builder ThisBuilder { | ||
6960 | get { return this; } | ||
6961 | } | ||
6962 | public Builder() {} | ||
6963 | |||
6964 | UUIDListProperty result = new UUIDListProperty(); | ||
6965 | |||
6966 | protected override UUIDListProperty MessageBeingBuilt { | ||
6967 | get { return result; } | ||
6968 | } | ||
6969 | |||
6970 | public override Builder Clear() { | ||
6971 | result = new UUIDListProperty(); | ||
6972 | return this; | ||
6973 | } | ||
6974 | |||
6975 | public override Builder Clone() { | ||
6976 | return new Builder().MergeFrom(result); | ||
6977 | } | ||
6978 | |||
6979 | public override pbd::MessageDescriptor DescriptorForType { | ||
6980 | get { return global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.Descriptor; } | ||
6981 | } | ||
6982 | |||
6983 | public override UUIDListProperty DefaultInstanceForType { | ||
6984 | get { return global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.DefaultInstance; } | ||
6985 | } | ||
6986 | |||
6987 | public override UUIDListProperty BuildPartial() { | ||
6988 | if (result == null) { | ||
6989 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
6990 | } | ||
6991 | result.value_.MakeReadOnly(); | ||
6992 | UUIDListProperty returnMe = result; | ||
6993 | result = null; | ||
6994 | return returnMe; | ||
6995 | } | ||
6996 | |||
6997 | public override Builder MergeFrom(pb::IMessage other) { | ||
6998 | if (other is UUIDListProperty) { | ||
6999 | return MergeFrom((UUIDListProperty) other); | ||
7000 | } else { | ||
7001 | base.MergeFrom(other); | ||
7002 | return this; | ||
7003 | } | ||
7004 | } | ||
7005 | |||
7006 | public override Builder MergeFrom(UUIDListProperty other) { | ||
7007 | if (other == global::Sirikata.Protocol._PBJ_Internal.UUIDListProperty.DefaultInstance) return this; | ||
7008 | if (other.value_.Count != 0) { | ||
7009 | base.AddRange(other.value_, result.value_); | ||
7010 | } | ||
7011 | this.MergeUnknownFields(other.UnknownFields); | ||
7012 | return this; | ||
7013 | } | ||
7014 | |||
7015 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
7016 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
7017 | } | ||
7018 | |||
7019 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
7020 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
7021 | while (true) { | ||
7022 | uint tag = input.ReadTag(); | ||
7023 | switch (tag) { | ||
7024 | case 0: { | ||
7025 | if (unknownFields != null) { | ||
7026 | this.UnknownFields = unknownFields.Build(); | ||
7027 | } | ||
7028 | return this; | ||
7029 | } | ||
7030 | default: { | ||
7031 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
7032 | if (unknownFields != null) { | ||
7033 | this.UnknownFields = unknownFields.Build(); | ||
7034 | } | ||
7035 | return this; | ||
7036 | } | ||
7037 | if (unknownFields == null) { | ||
7038 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
7039 | } | ||
7040 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
7041 | break; | ||
7042 | } | ||
7043 | case 82: { | ||
7044 | AddValue(input.ReadBytes()); | ||
7045 | break; | ||
7046 | } | ||
7047 | } | ||
7048 | } | ||
7049 | } | ||
7050 | |||
7051 | |||
7052 | public pbc::IPopsicleList<pb::ByteString> ValueList { | ||
7053 | get { return result.value_; } | ||
7054 | } | ||
7055 | public int ValueCount { | ||
7056 | get { return result.ValueCount; } | ||
7057 | } | ||
7058 | public pb::ByteString GetValue(int index) { | ||
7059 | return result.GetValue(index); | ||
7060 | } | ||
7061 | public Builder SetValue(int index, pb::ByteString value) { | ||
7062 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7063 | result.value_[index] = value; | ||
7064 | return this; | ||
7065 | } | ||
7066 | public Builder AddValue(pb::ByteString value) { | ||
7067 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7068 | result.value_.Add(value); | ||
7069 | return this; | ||
7070 | } | ||
7071 | public Builder AddRangeValue(scg::IEnumerable<pb::ByteString> values) { | ||
7072 | base.AddRange(values, result.value_); | ||
7073 | return this; | ||
7074 | } | ||
7075 | public Builder ClearValue() { | ||
7076 | result.value_.Clear(); | ||
7077 | return this; | ||
7078 | } | ||
7079 | } | ||
7080 | static UUIDListProperty() { | ||
7081 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
7082 | } | ||
7083 | } | ||
7084 | |||
7085 | public sealed partial class ConnectToSpace : pb::GeneratedMessage<ConnectToSpace, ConnectToSpace.Builder> { | ||
7086 | private static readonly ConnectToSpace defaultInstance = new Builder().BuildPartial(); | ||
7087 | public static ConnectToSpace DefaultInstance { | ||
7088 | get { return defaultInstance; } | ||
7089 | } | ||
7090 | |||
7091 | public override ConnectToSpace DefaultInstanceForType { | ||
7092 | get { return defaultInstance; } | ||
7093 | } | ||
7094 | |||
7095 | protected override ConnectToSpace ThisMessage { | ||
7096 | get { return this; } | ||
7097 | } | ||
7098 | |||
7099 | public static pbd::MessageDescriptor Descriptor { | ||
7100 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__Descriptor; } | ||
7101 | } | ||
7102 | |||
7103 | protected override pb::FieldAccess.FieldAccessorTable<ConnectToSpace, ConnectToSpace.Builder> InternalFieldAccessors { | ||
7104 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_ConnectToSpace__FieldAccessorTable; } | ||
7105 | } | ||
7106 | |||
7107 | public const int SpaceIdFieldNumber = 1; | ||
7108 | private bool hasSpaceId; | ||
7109 | private pb::ByteString spaceId_ = pb::ByteString.Empty; | ||
7110 | public bool HasSpaceId { | ||
7111 | get { return hasSpaceId; } | ||
7112 | } | ||
7113 | public pb::ByteString SpaceId { | ||
7114 | get { return spaceId_; } | ||
7115 | } | ||
7116 | |||
7117 | public const int ObjectUuidEvidenceFieldNumber = 2; | ||
7118 | private bool hasObjectUuidEvidence; | ||
7119 | private pb::ByteString objectUuidEvidence_ = pb::ByteString.Empty; | ||
7120 | public bool HasObjectUuidEvidence { | ||
7121 | get { return hasObjectUuidEvidence; } | ||
7122 | } | ||
7123 | public pb::ByteString ObjectUuidEvidence { | ||
7124 | get { return objectUuidEvidence_; } | ||
7125 | } | ||
7126 | |||
7127 | public const int RequestedObjectLocFieldNumber = 3; | ||
7128 | private bool hasRequestedObjectLoc; | ||
7129 | private global::Sirikata.Protocol._PBJ_Internal.ObjLoc requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; | ||
7130 | public bool HasRequestedObjectLoc { | ||
7131 | get { return hasRequestedObjectLoc; } | ||
7132 | } | ||
7133 | public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { | ||
7134 | get { return requestedObjectLoc_; } | ||
7135 | } | ||
7136 | |||
7137 | public const int BoundingSphereFieldNumber = 4; | ||
7138 | private int boundingSphereMemoizedSerializedSize; | ||
7139 | private pbc::PopsicleList<float> boundingSphere_ = new pbc::PopsicleList<float>(); | ||
7140 | public scg::IList<float> BoundingSphereList { | ||
7141 | get { return pbc::Lists.AsReadOnly(boundingSphere_); } | ||
7142 | } | ||
7143 | public int BoundingSphereCount { | ||
7144 | get { return boundingSphere_.Count; } | ||
7145 | } | ||
7146 | public float GetBoundingSphere(int index) { | ||
7147 | return boundingSphere_[index]; | ||
7148 | } | ||
7149 | |||
7150 | public override bool IsInitialized { | ||
7151 | get { | ||
7152 | return true; | ||
7153 | } | ||
7154 | } | ||
7155 | |||
7156 | public override void WriteTo(pb::CodedOutputStream output) { | ||
7157 | if (HasSpaceId) { | ||
7158 | output.WriteBytes(1, SpaceId); | ||
7159 | } | ||
7160 | if (HasObjectUuidEvidence) { | ||
7161 | output.WriteBytes(2, ObjectUuidEvidence); | ||
7162 | } | ||
7163 | if (HasRequestedObjectLoc) { | ||
7164 | output.WriteMessage(3, RequestedObjectLoc); | ||
7165 | } | ||
7166 | if (boundingSphere_.Count > 0) { | ||
7167 | output.WriteRawVarint32(34); | ||
7168 | output.WriteRawVarint32((uint) boundingSphereMemoizedSerializedSize); | ||
7169 | foreach (float element in boundingSphere_) { | ||
7170 | output.WriteFloatNoTag(element); | ||
7171 | } | ||
7172 | } | ||
7173 | UnknownFields.WriteTo(output); | ||
7174 | } | ||
7175 | |||
7176 | private int memoizedSerializedSize = -1; | ||
7177 | public override int SerializedSize { | ||
7178 | get { | ||
7179 | int size = memoizedSerializedSize; | ||
7180 | if (size != -1) return size; | ||
7181 | |||
7182 | size = 0; | ||
7183 | if (HasSpaceId) { | ||
7184 | size += pb::CodedOutputStream.ComputeBytesSize(1, SpaceId); | ||
7185 | } | ||
7186 | if (HasObjectUuidEvidence) { | ||
7187 | size += pb::CodedOutputStream.ComputeBytesSize(2, ObjectUuidEvidence); | ||
7188 | } | ||
7189 | if (HasRequestedObjectLoc) { | ||
7190 | size += pb::CodedOutputStream.ComputeMessageSize(3, RequestedObjectLoc); | ||
7191 | } | ||
7192 | { | ||
7193 | int dataSize = 0; | ||
7194 | dataSize = 4 * boundingSphere_.Count; | ||
7195 | size += dataSize; | ||
7196 | if (boundingSphere_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
7197 | boundingSphereMemoizedSerializedSize = dataSize; | ||
7198 | } | ||
7199 | size += UnknownFields.SerializedSize; | ||
7200 | memoizedSerializedSize = size; | ||
7201 | return size; | ||
7202 | } | ||
7203 | } | ||
7204 | |||
7205 | public static ConnectToSpace ParseFrom(pb::ByteString data) { | ||
7206 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
7207 | } | ||
7208 | public static ConnectToSpace ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
7209 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
7210 | } | ||
7211 | public static ConnectToSpace ParseFrom(byte[] data) { | ||
7212 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
7213 | } | ||
7214 | public static ConnectToSpace ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
7215 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
7216 | } | ||
7217 | public static ConnectToSpace ParseFrom(global::System.IO.Stream input) { | ||
7218 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
7219 | } | ||
7220 | public static ConnectToSpace ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
7221 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
7222 | } | ||
7223 | public static ConnectToSpace ParseDelimitedFrom(global::System.IO.Stream input) { | ||
7224 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
7225 | } | ||
7226 | public static ConnectToSpace ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
7227 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
7228 | } | ||
7229 | public static ConnectToSpace ParseFrom(pb::CodedInputStream input) { | ||
7230 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
7231 | } | ||
7232 | public static ConnectToSpace ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
7233 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
7234 | } | ||
7235 | public static Builder CreateBuilder() { return new Builder(); } | ||
7236 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
7237 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
7238 | public static Builder CreateBuilder(ConnectToSpace prototype) { | ||
7239 | return (Builder) new Builder().MergeFrom(prototype); | ||
7240 | } | ||
7241 | |||
7242 | public sealed partial class Builder : pb::GeneratedBuilder<ConnectToSpace, Builder> { | ||
7243 | protected override Builder ThisBuilder { | ||
7244 | get { return this; } | ||
7245 | } | ||
7246 | public Builder() {} | ||
7247 | |||
7248 | ConnectToSpace result = new ConnectToSpace(); | ||
7249 | |||
7250 | protected override ConnectToSpace MessageBeingBuilt { | ||
7251 | get { return result; } | ||
7252 | } | ||
7253 | |||
7254 | public override Builder Clear() { | ||
7255 | result = new ConnectToSpace(); | ||
7256 | return this; | ||
7257 | } | ||
7258 | |||
7259 | public override Builder Clone() { | ||
7260 | return new Builder().MergeFrom(result); | ||
7261 | } | ||
7262 | |||
7263 | public override pbd::MessageDescriptor DescriptorForType { | ||
7264 | get { return global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Descriptor; } | ||
7265 | } | ||
7266 | |||
7267 | public override ConnectToSpace DefaultInstanceForType { | ||
7268 | get { return global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.DefaultInstance; } | ||
7269 | } | ||
7270 | |||
7271 | public override ConnectToSpace BuildPartial() { | ||
7272 | if (result == null) { | ||
7273 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
7274 | } | ||
7275 | result.boundingSphere_.MakeReadOnly(); | ||
7276 | ConnectToSpace returnMe = result; | ||
7277 | result = null; | ||
7278 | return returnMe; | ||
7279 | } | ||
7280 | |||
7281 | public override Builder MergeFrom(pb::IMessage other) { | ||
7282 | if (other is ConnectToSpace) { | ||
7283 | return MergeFrom((ConnectToSpace) other); | ||
7284 | } else { | ||
7285 | base.MergeFrom(other); | ||
7286 | return this; | ||
7287 | } | ||
7288 | } | ||
7289 | |||
7290 | public override Builder MergeFrom(ConnectToSpace other) { | ||
7291 | if (other == global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.DefaultInstance) return this; | ||
7292 | if (other.HasSpaceId) { | ||
7293 | SpaceId = other.SpaceId; | ||
7294 | } | ||
7295 | if (other.HasObjectUuidEvidence) { | ||
7296 | ObjectUuidEvidence = other.ObjectUuidEvidence; | ||
7297 | } | ||
7298 | if (other.HasRequestedObjectLoc) { | ||
7299 | MergeRequestedObjectLoc(other.RequestedObjectLoc); | ||
7300 | } | ||
7301 | if (other.boundingSphere_.Count != 0) { | ||
7302 | base.AddRange(other.boundingSphere_, result.boundingSphere_); | ||
7303 | } | ||
7304 | this.MergeUnknownFields(other.UnknownFields); | ||
7305 | return this; | ||
7306 | } | ||
7307 | |||
7308 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
7309 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
7310 | } | ||
7311 | |||
7312 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
7313 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
7314 | while (true) { | ||
7315 | uint tag = input.ReadTag(); | ||
7316 | switch (tag) { | ||
7317 | case 0: { | ||
7318 | if (unknownFields != null) { | ||
7319 | this.UnknownFields = unknownFields.Build(); | ||
7320 | } | ||
7321 | return this; | ||
7322 | } | ||
7323 | default: { | ||
7324 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
7325 | if (unknownFields != null) { | ||
7326 | this.UnknownFields = unknownFields.Build(); | ||
7327 | } | ||
7328 | return this; | ||
7329 | } | ||
7330 | if (unknownFields == null) { | ||
7331 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
7332 | } | ||
7333 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
7334 | break; | ||
7335 | } | ||
7336 | case 10: { | ||
7337 | SpaceId = input.ReadBytes(); | ||
7338 | break; | ||
7339 | } | ||
7340 | case 18: { | ||
7341 | ObjectUuidEvidence = input.ReadBytes(); | ||
7342 | break; | ||
7343 | } | ||
7344 | case 26: { | ||
7345 | global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(); | ||
7346 | if (HasRequestedObjectLoc) { | ||
7347 | subBuilder.MergeFrom(RequestedObjectLoc); | ||
7348 | } | ||
7349 | input.ReadMessage(subBuilder, extensionRegistry); | ||
7350 | RequestedObjectLoc = subBuilder.BuildPartial(); | ||
7351 | break; | ||
7352 | } | ||
7353 | case 34: { | ||
7354 | int length = input.ReadInt32(); | ||
7355 | int limit = input.PushLimit(length); | ||
7356 | while (!input.ReachedLimit) { | ||
7357 | AddBoundingSphere(input.ReadFloat()); | ||
7358 | } | ||
7359 | input.PopLimit(limit); | ||
7360 | break; | ||
7361 | } | ||
7362 | } | ||
7363 | } | ||
7364 | } | ||
7365 | |||
7366 | |||
7367 | public bool HasSpaceId { | ||
7368 | get { return result.HasSpaceId; } | ||
7369 | } | ||
7370 | public pb::ByteString SpaceId { | ||
7371 | get { return result.SpaceId; } | ||
7372 | set { SetSpaceId(value); } | ||
7373 | } | ||
7374 | public Builder SetSpaceId(pb::ByteString value) { | ||
7375 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7376 | result.hasSpaceId = true; | ||
7377 | result.spaceId_ = value; | ||
7378 | return this; | ||
7379 | } | ||
7380 | public Builder ClearSpaceId() { | ||
7381 | result.hasSpaceId = false; | ||
7382 | result.spaceId_ = pb::ByteString.Empty; | ||
7383 | return this; | ||
7384 | } | ||
7385 | |||
7386 | public bool HasObjectUuidEvidence { | ||
7387 | get { return result.HasObjectUuidEvidence; } | ||
7388 | } | ||
7389 | public pb::ByteString ObjectUuidEvidence { | ||
7390 | get { return result.ObjectUuidEvidence; } | ||
7391 | set { SetObjectUuidEvidence(value); } | ||
7392 | } | ||
7393 | public Builder SetObjectUuidEvidence(pb::ByteString value) { | ||
7394 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7395 | result.hasObjectUuidEvidence = true; | ||
7396 | result.objectUuidEvidence_ = value; | ||
7397 | return this; | ||
7398 | } | ||
7399 | public Builder ClearObjectUuidEvidence() { | ||
7400 | result.hasObjectUuidEvidence = false; | ||
7401 | result.objectUuidEvidence_ = pb::ByteString.Empty; | ||
7402 | return this; | ||
7403 | } | ||
7404 | |||
7405 | public bool HasRequestedObjectLoc { | ||
7406 | get { return result.HasRequestedObjectLoc; } | ||
7407 | } | ||
7408 | public global::Sirikata.Protocol._PBJ_Internal.ObjLoc RequestedObjectLoc { | ||
7409 | get { return result.RequestedObjectLoc; } | ||
7410 | set { SetRequestedObjectLoc(value); } | ||
7411 | } | ||
7412 | public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { | ||
7413 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7414 | result.hasRequestedObjectLoc = true; | ||
7415 | result.requestedObjectLoc_ = value; | ||
7416 | return this; | ||
7417 | } | ||
7418 | public Builder SetRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc.Builder builderForValue) { | ||
7419 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
7420 | result.hasRequestedObjectLoc = true; | ||
7421 | result.requestedObjectLoc_ = builderForValue.Build(); | ||
7422 | return this; | ||
7423 | } | ||
7424 | public Builder MergeRequestedObjectLoc(global::Sirikata.Protocol._PBJ_Internal.ObjLoc value) { | ||
7425 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7426 | if (result.HasRequestedObjectLoc && | ||
7427 | result.requestedObjectLoc_ != global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance) { | ||
7428 | result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.CreateBuilder(result.requestedObjectLoc_).MergeFrom(value).BuildPartial(); | ||
7429 | } else { | ||
7430 | result.requestedObjectLoc_ = value; | ||
7431 | } | ||
7432 | result.hasRequestedObjectLoc = true; | ||
7433 | return this; | ||
7434 | } | ||
7435 | public Builder ClearRequestedObjectLoc() { | ||
7436 | result.hasRequestedObjectLoc = false; | ||
7437 | result.requestedObjectLoc_ = global::Sirikata.Protocol._PBJ_Internal.ObjLoc.DefaultInstance; | ||
7438 | return this; | ||
7439 | } | ||
7440 | |||
7441 | public pbc::IPopsicleList<float> BoundingSphereList { | ||
7442 | get { return result.boundingSphere_; } | ||
7443 | } | ||
7444 | public int BoundingSphereCount { | ||
7445 | get { return result.BoundingSphereCount; } | ||
7446 | } | ||
7447 | public float GetBoundingSphere(int index) { | ||
7448 | return result.GetBoundingSphere(index); | ||
7449 | } | ||
7450 | public Builder SetBoundingSphere(int index, float value) { | ||
7451 | result.boundingSphere_[index] = value; | ||
7452 | return this; | ||
7453 | } | ||
7454 | public Builder AddBoundingSphere(float value) { | ||
7455 | result.boundingSphere_.Add(value); | ||
7456 | return this; | ||
7457 | } | ||
7458 | public Builder AddRangeBoundingSphere(scg::IEnumerable<float> values) { | ||
7459 | base.AddRange(values, result.boundingSphere_); | ||
7460 | return this; | ||
7461 | } | ||
7462 | public Builder ClearBoundingSphere() { | ||
7463 | result.boundingSphere_.Clear(); | ||
7464 | return this; | ||
7465 | } | ||
7466 | } | ||
7467 | static ConnectToSpace() { | ||
7468 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
7469 | } | ||
7470 | } | ||
7471 | |||
7472 | public sealed partial class CreateObject : pb::GeneratedMessage<CreateObject, CreateObject.Builder> { | ||
7473 | private static readonly CreateObject defaultInstance = new Builder().BuildPartial(); | ||
7474 | public static CreateObject DefaultInstance { | ||
7475 | get { return defaultInstance; } | ||
7476 | } | ||
7477 | |||
7478 | public override CreateObject DefaultInstanceForType { | ||
7479 | get { return defaultInstance; } | ||
7480 | } | ||
7481 | |||
7482 | protected override CreateObject ThisMessage { | ||
7483 | get { return this; } | ||
7484 | } | ||
7485 | |||
7486 | public static pbd::MessageDescriptor Descriptor { | ||
7487 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__Descriptor; } | ||
7488 | } | ||
7489 | |||
7490 | protected override pb::FieldAccess.FieldAccessorTable<CreateObject, CreateObject.Builder> InternalFieldAccessors { | ||
7491 | get { return global::Sirikata.Protocol._PBJ_Internal.Sirikata.internal__static_Sirikata_Protocol__PBJ_Internal_CreateObject__FieldAccessorTable; } | ||
7492 | } | ||
7493 | |||
7494 | public const int ObjectUuidFieldNumber = 1; | ||
7495 | private bool hasObjectUuid; | ||
7496 | private pb::ByteString objectUuid_ = pb::ByteString.Empty; | ||
7497 | public bool HasObjectUuid { | ||
7498 | get { return hasObjectUuid; } | ||
7499 | } | ||
7500 | public pb::ByteString ObjectUuid { | ||
7501 | get { return objectUuid_; } | ||
7502 | } | ||
7503 | |||
7504 | public const int SpacePropertiesFieldNumber = 2; | ||
7505 | private pbc::PopsicleList<global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace> spaceProperties_ = new pbc::PopsicleList<global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace>(); | ||
7506 | public scg::IList<global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace> SpacePropertiesList { | ||
7507 | get { return spaceProperties_; } | ||
7508 | } | ||
7509 | public int SpacePropertiesCount { | ||
7510 | get { return spaceProperties_.Count; } | ||
7511 | } | ||
7512 | public global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace GetSpaceProperties(int index) { | ||
7513 | return spaceProperties_[index]; | ||
7514 | } | ||
7515 | |||
7516 | public const int MeshFieldNumber = 3; | ||
7517 | private bool hasMesh; | ||
7518 | private string mesh_ = ""; | ||
7519 | public bool HasMesh { | ||
7520 | get { return hasMesh; } | ||
7521 | } | ||
7522 | public string Mesh { | ||
7523 | get { return mesh_; } | ||
7524 | } | ||
7525 | |||
7526 | public const int ScaleFieldNumber = 4; | ||
7527 | private int scaleMemoizedSerializedSize; | ||
7528 | private pbc::PopsicleList<float> scale_ = new pbc::PopsicleList<float>(); | ||
7529 | public scg::IList<float> ScaleList { | ||
7530 | get { return pbc::Lists.AsReadOnly(scale_); } | ||
7531 | } | ||
7532 | public int ScaleCount { | ||
7533 | get { return scale_.Count; } | ||
7534 | } | ||
7535 | public float GetScale(int index) { | ||
7536 | return scale_[index]; | ||
7537 | } | ||
7538 | |||
7539 | public const int WeburlFieldNumber = 5; | ||
7540 | private bool hasWeburl; | ||
7541 | private string weburl_ = ""; | ||
7542 | public bool HasWeburl { | ||
7543 | get { return hasWeburl; } | ||
7544 | } | ||
7545 | public string Weburl { | ||
7546 | get { return weburl_; } | ||
7547 | } | ||
7548 | |||
7549 | public const int LightInfoFieldNumber = 6; | ||
7550 | private bool hasLightInfo; | ||
7551 | private global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; | ||
7552 | public bool HasLightInfo { | ||
7553 | get { return hasLightInfo; } | ||
7554 | } | ||
7555 | public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty LightInfo { | ||
7556 | get { return lightInfo_; } | ||
7557 | } | ||
7558 | |||
7559 | public const int CameraFieldNumber = 7; | ||
7560 | private bool hasCamera; | ||
7561 | private bool camera_ = false; | ||
7562 | public bool HasCamera { | ||
7563 | get { return hasCamera; } | ||
7564 | } | ||
7565 | public bool Camera { | ||
7566 | get { return camera_; } | ||
7567 | } | ||
7568 | |||
7569 | public const int PhysicalFieldNumber = 8; | ||
7570 | private bool hasPhysical; | ||
7571 | private global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; | ||
7572 | public bool HasPhysical { | ||
7573 | get { return hasPhysical; } | ||
7574 | } | ||
7575 | public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters Physical { | ||
7576 | get { return physical_; } | ||
7577 | } | ||
7578 | |||
7579 | public override bool IsInitialized { | ||
7580 | get { | ||
7581 | return true; | ||
7582 | } | ||
7583 | } | ||
7584 | |||
7585 | public override void WriteTo(pb::CodedOutputStream output) { | ||
7586 | if (HasObjectUuid) { | ||
7587 | output.WriteBytes(1, ObjectUuid); | ||
7588 | } | ||
7589 | foreach (global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace element in SpacePropertiesList) { | ||
7590 | output.WriteMessage(2, element); | ||
7591 | } | ||
7592 | if (HasMesh) { | ||
7593 | output.WriteString(3, Mesh); | ||
7594 | } | ||
7595 | if (scale_.Count > 0) { | ||
7596 | output.WriteRawVarint32(34); | ||
7597 | output.WriteRawVarint32((uint) scaleMemoizedSerializedSize); | ||
7598 | foreach (float element in scale_) { | ||
7599 | output.WriteFloatNoTag(element); | ||
7600 | } | ||
7601 | } | ||
7602 | if (HasWeburl) { | ||
7603 | output.WriteString(5, Weburl); | ||
7604 | } | ||
7605 | if (HasLightInfo) { | ||
7606 | output.WriteMessage(6, LightInfo); | ||
7607 | } | ||
7608 | if (HasCamera) { | ||
7609 | output.WriteBool(7, Camera); | ||
7610 | } | ||
7611 | if (HasPhysical) { | ||
7612 | output.WriteMessage(8, Physical); | ||
7613 | } | ||
7614 | UnknownFields.WriteTo(output); | ||
7615 | } | ||
7616 | |||
7617 | private int memoizedSerializedSize = -1; | ||
7618 | public override int SerializedSize { | ||
7619 | get { | ||
7620 | int size = memoizedSerializedSize; | ||
7621 | if (size != -1) return size; | ||
7622 | |||
7623 | size = 0; | ||
7624 | if (HasObjectUuid) { | ||
7625 | size += pb::CodedOutputStream.ComputeBytesSize(1, ObjectUuid); | ||
7626 | } | ||
7627 | foreach (global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace element in SpacePropertiesList) { | ||
7628 | size += pb::CodedOutputStream.ComputeMessageSize(2, element); | ||
7629 | } | ||
7630 | if (HasMesh) { | ||
7631 | size += pb::CodedOutputStream.ComputeStringSize(3, Mesh); | ||
7632 | } | ||
7633 | { | ||
7634 | int dataSize = 0; | ||
7635 | dataSize = 4 * scale_.Count; | ||
7636 | size += dataSize; | ||
7637 | if (scale_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
7638 | scaleMemoizedSerializedSize = dataSize; | ||
7639 | } | ||
7640 | if (HasWeburl) { | ||
7641 | size += pb::CodedOutputStream.ComputeStringSize(5, Weburl); | ||
7642 | } | ||
7643 | if (HasLightInfo) { | ||
7644 | size += pb::CodedOutputStream.ComputeMessageSize(6, LightInfo); | ||
7645 | } | ||
7646 | if (HasCamera) { | ||
7647 | size += pb::CodedOutputStream.ComputeBoolSize(7, Camera); | ||
7648 | } | ||
7649 | if (HasPhysical) { | ||
7650 | size += pb::CodedOutputStream.ComputeMessageSize(8, Physical); | ||
7651 | } | ||
7652 | size += UnknownFields.SerializedSize; | ||
7653 | memoizedSerializedSize = size; | ||
7654 | return size; | ||
7655 | } | ||
7656 | } | ||
7657 | |||
7658 | public static CreateObject ParseFrom(pb::ByteString data) { | ||
7659 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
7660 | } | ||
7661 | public static CreateObject ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
7662 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
7663 | } | ||
7664 | public static CreateObject ParseFrom(byte[] data) { | ||
7665 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
7666 | } | ||
7667 | public static CreateObject ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
7668 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
7669 | } | ||
7670 | public static CreateObject ParseFrom(global::System.IO.Stream input) { | ||
7671 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
7672 | } | ||
7673 | public static CreateObject ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
7674 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
7675 | } | ||
7676 | public static CreateObject ParseDelimitedFrom(global::System.IO.Stream input) { | ||
7677 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
7678 | } | ||
7679 | public static CreateObject ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
7680 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
7681 | } | ||
7682 | public static CreateObject ParseFrom(pb::CodedInputStream input) { | ||
7683 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
7684 | } | ||
7685 | public static CreateObject ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
7686 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
7687 | } | ||
7688 | public static Builder CreateBuilder() { return new Builder(); } | ||
7689 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
7690 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
7691 | public static Builder CreateBuilder(CreateObject prototype) { | ||
7692 | return (Builder) new Builder().MergeFrom(prototype); | ||
7693 | } | ||
7694 | |||
7695 | public sealed partial class Builder : pb::GeneratedBuilder<CreateObject, Builder> { | ||
7696 | protected override Builder ThisBuilder { | ||
7697 | get { return this; } | ||
7698 | } | ||
7699 | public Builder() {} | ||
7700 | |||
7701 | CreateObject result = new CreateObject(); | ||
7702 | |||
7703 | protected override CreateObject MessageBeingBuilt { | ||
7704 | get { return result; } | ||
7705 | } | ||
7706 | |||
7707 | public override Builder Clear() { | ||
7708 | result = new CreateObject(); | ||
7709 | return this; | ||
7710 | } | ||
7711 | |||
7712 | public override Builder Clone() { | ||
7713 | return new Builder().MergeFrom(result); | ||
7714 | } | ||
7715 | |||
7716 | public override pbd::MessageDescriptor DescriptorForType { | ||
7717 | get { return global::Sirikata.Protocol._PBJ_Internal.CreateObject.Descriptor; } | ||
7718 | } | ||
7719 | |||
7720 | public override CreateObject DefaultInstanceForType { | ||
7721 | get { return global::Sirikata.Protocol._PBJ_Internal.CreateObject.DefaultInstance; } | ||
7722 | } | ||
7723 | |||
7724 | public override CreateObject BuildPartial() { | ||
7725 | if (result == null) { | ||
7726 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
7727 | } | ||
7728 | result.spaceProperties_.MakeReadOnly(); | ||
7729 | result.scale_.MakeReadOnly(); | ||
7730 | CreateObject returnMe = result; | ||
7731 | result = null; | ||
7732 | return returnMe; | ||
7733 | } | ||
7734 | |||
7735 | public override Builder MergeFrom(pb::IMessage other) { | ||
7736 | if (other is CreateObject) { | ||
7737 | return MergeFrom((CreateObject) other); | ||
7738 | } else { | ||
7739 | base.MergeFrom(other); | ||
7740 | return this; | ||
7741 | } | ||
7742 | } | ||
7743 | |||
7744 | public override Builder MergeFrom(CreateObject other) { | ||
7745 | if (other == global::Sirikata.Protocol._PBJ_Internal.CreateObject.DefaultInstance) return this; | ||
7746 | if (other.HasObjectUuid) { | ||
7747 | ObjectUuid = other.ObjectUuid; | ||
7748 | } | ||
7749 | if (other.spaceProperties_.Count != 0) { | ||
7750 | base.AddRange(other.spaceProperties_, result.spaceProperties_); | ||
7751 | } | ||
7752 | if (other.HasMesh) { | ||
7753 | Mesh = other.Mesh; | ||
7754 | } | ||
7755 | if (other.scale_.Count != 0) { | ||
7756 | base.AddRange(other.scale_, result.scale_); | ||
7757 | } | ||
7758 | if (other.HasWeburl) { | ||
7759 | Weburl = other.Weburl; | ||
7760 | } | ||
7761 | if (other.HasLightInfo) { | ||
7762 | MergeLightInfo(other.LightInfo); | ||
7763 | } | ||
7764 | if (other.HasCamera) { | ||
7765 | Camera = other.Camera; | ||
7766 | } | ||
7767 | if (other.HasPhysical) { | ||
7768 | MergePhysical(other.Physical); | ||
7769 | } | ||
7770 | this.MergeUnknownFields(other.UnknownFields); | ||
7771 | return this; | ||
7772 | } | ||
7773 | |||
7774 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
7775 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
7776 | } | ||
7777 | |||
7778 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
7779 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
7780 | while (true) { | ||
7781 | uint tag = input.ReadTag(); | ||
7782 | switch (tag) { | ||
7783 | case 0: { | ||
7784 | if (unknownFields != null) { | ||
7785 | this.UnknownFields = unknownFields.Build(); | ||
7786 | } | ||
7787 | return this; | ||
7788 | } | ||
7789 | default: { | ||
7790 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
7791 | if (unknownFields != null) { | ||
7792 | this.UnknownFields = unknownFields.Build(); | ||
7793 | } | ||
7794 | return this; | ||
7795 | } | ||
7796 | if (unknownFields == null) { | ||
7797 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
7798 | } | ||
7799 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
7800 | break; | ||
7801 | } | ||
7802 | case 10: { | ||
7803 | ObjectUuid = input.ReadBytes(); | ||
7804 | break; | ||
7805 | } | ||
7806 | case 18: { | ||
7807 | global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.CreateBuilder(); | ||
7808 | input.ReadMessage(subBuilder, extensionRegistry); | ||
7809 | AddSpaceProperties(subBuilder.BuildPartial()); | ||
7810 | break; | ||
7811 | } | ||
7812 | case 26: { | ||
7813 | Mesh = input.ReadString(); | ||
7814 | break; | ||
7815 | } | ||
7816 | case 34: { | ||
7817 | int length = input.ReadInt32(); | ||
7818 | int limit = input.PushLimit(length); | ||
7819 | while (!input.ReachedLimit) { | ||
7820 | AddScale(input.ReadFloat()); | ||
7821 | } | ||
7822 | input.PopLimit(limit); | ||
7823 | break; | ||
7824 | } | ||
7825 | case 42: { | ||
7826 | Weburl = input.ReadString(); | ||
7827 | break; | ||
7828 | } | ||
7829 | case 50: { | ||
7830 | global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.CreateBuilder(); | ||
7831 | if (HasLightInfo) { | ||
7832 | subBuilder.MergeFrom(LightInfo); | ||
7833 | } | ||
7834 | input.ReadMessage(subBuilder, extensionRegistry); | ||
7835 | LightInfo = subBuilder.BuildPartial(); | ||
7836 | break; | ||
7837 | } | ||
7838 | case 56: { | ||
7839 | Camera = input.ReadBool(); | ||
7840 | break; | ||
7841 | } | ||
7842 | case 66: { | ||
7843 | global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder subBuilder = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.CreateBuilder(); | ||
7844 | if (HasPhysical) { | ||
7845 | subBuilder.MergeFrom(Physical); | ||
7846 | } | ||
7847 | input.ReadMessage(subBuilder, extensionRegistry); | ||
7848 | Physical = subBuilder.BuildPartial(); | ||
7849 | break; | ||
7850 | } | ||
7851 | } | ||
7852 | } | ||
7853 | } | ||
7854 | |||
7855 | |||
7856 | public bool HasObjectUuid { | ||
7857 | get { return result.HasObjectUuid; } | ||
7858 | } | ||
7859 | public pb::ByteString ObjectUuid { | ||
7860 | get { return result.ObjectUuid; } | ||
7861 | set { SetObjectUuid(value); } | ||
7862 | } | ||
7863 | public Builder SetObjectUuid(pb::ByteString value) { | ||
7864 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7865 | result.hasObjectUuid = true; | ||
7866 | result.objectUuid_ = value; | ||
7867 | return this; | ||
7868 | } | ||
7869 | public Builder ClearObjectUuid() { | ||
7870 | result.hasObjectUuid = false; | ||
7871 | result.objectUuid_ = pb::ByteString.Empty; | ||
7872 | return this; | ||
7873 | } | ||
7874 | |||
7875 | public pbc::IPopsicleList<global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace> SpacePropertiesList { | ||
7876 | get { return result.spaceProperties_; } | ||
7877 | } | ||
7878 | public int SpacePropertiesCount { | ||
7879 | get { return result.SpacePropertiesCount; } | ||
7880 | } | ||
7881 | public global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace GetSpaceProperties(int index) { | ||
7882 | return result.GetSpaceProperties(index); | ||
7883 | } | ||
7884 | public Builder SetSpaceProperties(int index, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace value) { | ||
7885 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7886 | result.spaceProperties_[index] = value; | ||
7887 | return this; | ||
7888 | } | ||
7889 | public Builder SetSpaceProperties(int index, global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder builderForValue) { | ||
7890 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
7891 | result.spaceProperties_[index] = builderForValue.Build(); | ||
7892 | return this; | ||
7893 | } | ||
7894 | public Builder AddSpaceProperties(global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace value) { | ||
7895 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7896 | result.spaceProperties_.Add(value); | ||
7897 | return this; | ||
7898 | } | ||
7899 | public Builder AddSpaceProperties(global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace.Builder builderForValue) { | ||
7900 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
7901 | result.spaceProperties_.Add(builderForValue.Build()); | ||
7902 | return this; | ||
7903 | } | ||
7904 | public Builder AddRangeSpaceProperties(scg::IEnumerable<global::Sirikata.Protocol._PBJ_Internal.ConnectToSpace> values) { | ||
7905 | base.AddRange(values, result.spaceProperties_); | ||
7906 | return this; | ||
7907 | } | ||
7908 | public Builder ClearSpaceProperties() { | ||
7909 | result.spaceProperties_.Clear(); | ||
7910 | return this; | ||
7911 | } | ||
7912 | |||
7913 | public bool HasMesh { | ||
7914 | get { return result.HasMesh; } | ||
7915 | } | ||
7916 | public string Mesh { | ||
7917 | get { return result.Mesh; } | ||
7918 | set { SetMesh(value); } | ||
7919 | } | ||
7920 | public Builder SetMesh(string value) { | ||
7921 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7922 | result.hasMesh = true; | ||
7923 | result.mesh_ = value; | ||
7924 | return this; | ||
7925 | } | ||
7926 | public Builder ClearMesh() { | ||
7927 | result.hasMesh = false; | ||
7928 | result.mesh_ = ""; | ||
7929 | return this; | ||
7930 | } | ||
7931 | |||
7932 | public pbc::IPopsicleList<float> ScaleList { | ||
7933 | get { return result.scale_; } | ||
7934 | } | ||
7935 | public int ScaleCount { | ||
7936 | get { return result.ScaleCount; } | ||
7937 | } | ||
7938 | public float GetScale(int index) { | ||
7939 | return result.GetScale(index); | ||
7940 | } | ||
7941 | public Builder SetScale(int index, float value) { | ||
7942 | result.scale_[index] = value; | ||
7943 | return this; | ||
7944 | } | ||
7945 | public Builder AddScale(float value) { | ||
7946 | result.scale_.Add(value); | ||
7947 | return this; | ||
7948 | } | ||
7949 | public Builder AddRangeScale(scg::IEnumerable<float> values) { | ||
7950 | base.AddRange(values, result.scale_); | ||
7951 | return this; | ||
7952 | } | ||
7953 | public Builder ClearScale() { | ||
7954 | result.scale_.Clear(); | ||
7955 | return this; | ||
7956 | } | ||
7957 | |||
7958 | public bool HasWeburl { | ||
7959 | get { return result.HasWeburl; } | ||
7960 | } | ||
7961 | public string Weburl { | ||
7962 | get { return result.Weburl; } | ||
7963 | set { SetWeburl(value); } | ||
7964 | } | ||
7965 | public Builder SetWeburl(string value) { | ||
7966 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7967 | result.hasWeburl = true; | ||
7968 | result.weburl_ = value; | ||
7969 | return this; | ||
7970 | } | ||
7971 | public Builder ClearWeburl() { | ||
7972 | result.hasWeburl = false; | ||
7973 | result.weburl_ = ""; | ||
7974 | return this; | ||
7975 | } | ||
7976 | |||
7977 | public bool HasLightInfo { | ||
7978 | get { return result.HasLightInfo; } | ||
7979 | } | ||
7980 | public global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty LightInfo { | ||
7981 | get { return result.LightInfo; } | ||
7982 | set { SetLightInfo(value); } | ||
7983 | } | ||
7984 | public Builder SetLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty value) { | ||
7985 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7986 | result.hasLightInfo = true; | ||
7987 | result.lightInfo_ = value; | ||
7988 | return this; | ||
7989 | } | ||
7990 | public Builder SetLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.Builder builderForValue) { | ||
7991 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
7992 | result.hasLightInfo = true; | ||
7993 | result.lightInfo_ = builderForValue.Build(); | ||
7994 | return this; | ||
7995 | } | ||
7996 | public Builder MergeLightInfo(global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty value) { | ||
7997 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
7998 | if (result.HasLightInfo && | ||
7999 | result.lightInfo_ != global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance) { | ||
8000 | result.lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.CreateBuilder(result.lightInfo_).MergeFrom(value).BuildPartial(); | ||
8001 | } else { | ||
8002 | result.lightInfo_ = value; | ||
8003 | } | ||
8004 | result.hasLightInfo = true; | ||
8005 | return this; | ||
8006 | } | ||
8007 | public Builder ClearLightInfo() { | ||
8008 | result.hasLightInfo = false; | ||
8009 | result.lightInfo_ = global::Sirikata.Protocol._PBJ_Internal.LightInfoProperty.DefaultInstance; | ||
8010 | return this; | ||
8011 | } | ||
8012 | |||
8013 | public bool HasCamera { | ||
8014 | get { return result.HasCamera; } | ||
8015 | } | ||
8016 | public bool Camera { | ||
8017 | get { return result.Camera; } | ||
8018 | set { SetCamera(value); } | ||
8019 | } | ||
8020 | public Builder SetCamera(bool value) { | ||
8021 | result.hasCamera = true; | ||
8022 | result.camera_ = value; | ||
8023 | return this; | ||
8024 | } | ||
8025 | public Builder ClearCamera() { | ||
8026 | result.hasCamera = false; | ||
8027 | result.camera_ = false; | ||
8028 | return this; | ||
8029 | } | ||
8030 | |||
8031 | public bool HasPhysical { | ||
8032 | get { return result.HasPhysical; } | ||
8033 | } | ||
8034 | public global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters Physical { | ||
8035 | get { return result.Physical; } | ||
8036 | set { SetPhysical(value); } | ||
8037 | } | ||
8038 | public Builder SetPhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters value) { | ||
8039 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
8040 | result.hasPhysical = true; | ||
8041 | result.physical_ = value; | ||
8042 | return this; | ||
8043 | } | ||
8044 | public Builder SetPhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.Builder builderForValue) { | ||
8045 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
8046 | result.hasPhysical = true; | ||
8047 | result.physical_ = builderForValue.Build(); | ||
8048 | return this; | ||
8049 | } | ||
8050 | public Builder MergePhysical(global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters value) { | ||
8051 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
8052 | if (result.HasPhysical && | ||
8053 | result.physical_ != global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance) { | ||
8054 | result.physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.CreateBuilder(result.physical_).MergeFrom(value).BuildPartial(); | ||
8055 | } else { | ||
8056 | result.physical_ = value; | ||
8057 | } | ||
8058 | result.hasPhysical = true; | ||
8059 | return this; | ||
8060 | } | ||
8061 | public Builder ClearPhysical() { | ||
8062 | result.hasPhysical = false; | ||
8063 | result.physical_ = global::Sirikata.Protocol._PBJ_Internal.PhysicalParameters.DefaultInstance; | ||
8064 | return this; | ||
8065 | } | ||
8066 | } | ||
8067 | static CreateObject() { | ||
8068 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.Sirikata.Descriptor, null); | ||
8069 | } | ||
8070 | } | ||
8071 | |||
8072 | #endregion | ||
8073 | |||
8074 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs deleted file mode 100644 index fcf0152..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs +++ /dev/null | |||
@@ -1,3934 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace Sirikata.Protocol { | ||
31 | public class MessageBody : PBJ.IMessage { | ||
32 | protected _PBJ_Internal.MessageBody super; | ||
33 | public _PBJ_Internal.MessageBody _PBJSuper{ get { return super;} } | ||
34 | public MessageBody() { | ||
35 | super=new _PBJ_Internal.MessageBody(); | ||
36 | } | ||
37 | public MessageBody(_PBJ_Internal.MessageBody reference) { | ||
38 | super=reference; | ||
39 | } | ||
40 | public static MessageBody defaultInstance= new MessageBody (_PBJ_Internal.MessageBody.DefaultInstance); | ||
41 | public static MessageBody DefaultInstance{ | ||
42 | get {return defaultInstance;} | ||
43 | } | ||
44 | public static pbd.MessageDescriptor Descriptor { | ||
45 | get { return _PBJ_Internal.MessageBody.Descriptor; } } | ||
46 | public static class Types { | ||
47 | } | ||
48 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
49 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
50 | } | ||
51 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
52 | return false; | ||
53 | } | ||
54 | public const int MessageNamesFieldTag=9; | ||
55 | public int MessageNamesCount { get { return super.MessageNamesCount;} } | ||
56 | public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} | ||
57 | public string MessageNames(int index) { | ||
58 | return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); | ||
59 | } | ||
60 | public const int MessageArgumentsFieldTag=10; | ||
61 | public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } | ||
62 | public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} | ||
63 | public pb::ByteString MessageArguments(int index) { | ||
64 | return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); | ||
65 | } | ||
66 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
67 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
68 | public static Builder CreateBuilder() { return new Builder(); } | ||
69 | public static Builder CreateBuilder(MessageBody prototype) { | ||
70 | return (Builder)new Builder().MergeFrom(prototype); | ||
71 | } | ||
72 | public static MessageBody ParseFrom(pb::ByteString data) { | ||
73 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); | ||
74 | } | ||
75 | public static MessageBody ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
76 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); | ||
77 | } | ||
78 | public static MessageBody ParseFrom(byte[] data) { | ||
79 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); | ||
80 | } | ||
81 | public static MessageBody ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
82 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); | ||
83 | } | ||
84 | public static MessageBody ParseFrom(global::System.IO.Stream data) { | ||
85 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); | ||
86 | } | ||
87 | public static MessageBody ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
88 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); | ||
89 | } | ||
90 | public static MessageBody ParseFrom(pb::CodedInputStream data) { | ||
91 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data)); | ||
92 | } | ||
93 | public static MessageBody ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
94 | return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er)); | ||
95 | } | ||
96 | protected override bool _HasAllPBJFields{ get { | ||
97 | return true | ||
98 | ; | ||
99 | } } | ||
100 | public bool IsInitialized { get { | ||
101 | return super.IsInitialized&&_HasAllPBJFields; | ||
102 | } } | ||
103 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
104 | protected override bool _HasAllPBJFields{ get { | ||
105 | return true | ||
106 | ; | ||
107 | } } | ||
108 | public bool IsInitialized { get { | ||
109 | return super.IsInitialized&&_HasAllPBJFields; | ||
110 | } } | ||
111 | protected _PBJ_Internal.MessageBody.Builder super; | ||
112 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
113 | public _PBJ_Internal.MessageBody.Builder _PBJSuper{ get { return super;} } | ||
114 | public Builder() {super = new _PBJ_Internal.MessageBody.Builder();} | ||
115 | public Builder(_PBJ_Internal.MessageBody.Builder other) { | ||
116 | super=other; | ||
117 | } | ||
118 | public Builder Clone() {return new Builder(super.Clone());} | ||
119 | public Builder MergeFrom(MessageBody prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
120 | public Builder Clear() {super.Clear();return this;} | ||
121 | public MessageBody BuildPartial() {return new MessageBody(super.BuildPartial());} | ||
122 | public MessageBody Build() {if (_HasAllPBJFields) return new MessageBody(super.Build());return null;} | ||
123 | public pbd::MessageDescriptor DescriptorForType { | ||
124 | get { return MessageBody.Descriptor; } } | ||
125 | public Builder ClearMessageNames() { super.ClearMessageNames();return this;} | ||
126 | public Builder SetMessageNames(int index, string value) { | ||
127 | super.SetMessageNames(index,PBJ._PBJ.Construct(value)); | ||
128 | return this; | ||
129 | } | ||
130 | public const int MessageNamesFieldTag=9; | ||
131 | public int MessageNamesCount { get { return super.MessageNamesCount;} } | ||
132 | public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} | ||
133 | public string MessageNames(int index) { | ||
134 | return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); | ||
135 | } | ||
136 | public Builder AddMessageNames(string value) { | ||
137 | super.AddMessageNames(PBJ._PBJ.Construct(value)); | ||
138 | return this; | ||
139 | } | ||
140 | public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;} | ||
141 | public Builder SetMessageArguments(int index, pb::ByteString value) { | ||
142 | super.SetMessageArguments(index,PBJ._PBJ.Construct(value)); | ||
143 | return this; | ||
144 | } | ||
145 | public const int MessageArgumentsFieldTag=10; | ||
146 | public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } | ||
147 | public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} | ||
148 | public pb::ByteString MessageArguments(int index) { | ||
149 | return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); | ||
150 | } | ||
151 | public Builder AddMessageArguments(pb::ByteString value) { | ||
152 | super.AddMessageArguments(PBJ._PBJ.Construct(value)); | ||
153 | return this; | ||
154 | } | ||
155 | } | ||
156 | } | ||
157 | } | ||
158 | namespace Sirikata.Protocol { | ||
159 | public class ReadOnlyMessage : PBJ.IMessage { | ||
160 | protected _PBJ_Internal.ReadOnlyMessage super; | ||
161 | public _PBJ_Internal.ReadOnlyMessage _PBJSuper{ get { return super;} } | ||
162 | public ReadOnlyMessage() { | ||
163 | super=new _PBJ_Internal.ReadOnlyMessage(); | ||
164 | } | ||
165 | public ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage reference) { | ||
166 | super=reference; | ||
167 | } | ||
168 | public static ReadOnlyMessage defaultInstance= new ReadOnlyMessage (_PBJ_Internal.ReadOnlyMessage.DefaultInstance); | ||
169 | public static ReadOnlyMessage DefaultInstance{ | ||
170 | get {return defaultInstance;} | ||
171 | } | ||
172 | public static pbd.MessageDescriptor Descriptor { | ||
173 | get { return _PBJ_Internal.ReadOnlyMessage.Descriptor; } } | ||
174 | public static class Types { | ||
175 | public enum ReturnStatus { | ||
176 | SUCCESS=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS, | ||
177 | NETWORK_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.NETWORK_FAILURE, | ||
178 | TIMEOUT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.TIMEOUT_FAILURE, | ||
179 | PROTOCOL_ERROR=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PROTOCOL_ERROR, | ||
180 | PORT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PORT_FAILURE | ||
181 | }; | ||
182 | } | ||
183 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
184 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
185 | } | ||
186 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
187 | return false; | ||
188 | } | ||
189 | public const int SourceObjectFieldTag=1; | ||
190 | public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } | ||
191 | public PBJ.UUID SourceObject{ get { | ||
192 | if (HasSourceObject) { | ||
193 | return PBJ._PBJ.CastUuid(super.SourceObject); | ||
194 | } else { | ||
195 | return PBJ._PBJ.CastUuid(); | ||
196 | } | ||
197 | } | ||
198 | } | ||
199 | public const int SourcePortFieldTag=3; | ||
200 | public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } | ||
201 | public uint SourcePort{ get { | ||
202 | if (HasSourcePort) { | ||
203 | return PBJ._PBJ.CastUint32(super.SourcePort); | ||
204 | } else { | ||
205 | return PBJ._PBJ.CastUint32(); | ||
206 | } | ||
207 | } | ||
208 | } | ||
209 | public const int SourceSpaceFieldTag=1536; | ||
210 | public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } | ||
211 | public PBJ.UUID SourceSpace{ get { | ||
212 | if (HasSourceSpace) { | ||
213 | return PBJ._PBJ.CastUuid(super.SourceSpace); | ||
214 | } else { | ||
215 | return PBJ._PBJ.CastUuid(); | ||
216 | } | ||
217 | } | ||
218 | } | ||
219 | public const int DestinationObjectFieldTag=2; | ||
220 | public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } | ||
221 | public PBJ.UUID DestinationObject{ get { | ||
222 | if (HasDestinationObject) { | ||
223 | return PBJ._PBJ.CastUuid(super.DestinationObject); | ||
224 | } else { | ||
225 | return PBJ._PBJ.CastUuid(); | ||
226 | } | ||
227 | } | ||
228 | } | ||
229 | public const int DestinationPortFieldTag=4; | ||
230 | public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } | ||
231 | public uint DestinationPort{ get { | ||
232 | if (HasDestinationPort) { | ||
233 | return PBJ._PBJ.CastUint32(super.DestinationPort); | ||
234 | } else { | ||
235 | return PBJ._PBJ.CastUint32(); | ||
236 | } | ||
237 | } | ||
238 | } | ||
239 | public const int DestinationSpaceFieldTag=1537; | ||
240 | public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } | ||
241 | public PBJ.UUID DestinationSpace{ get { | ||
242 | if (HasDestinationSpace) { | ||
243 | return PBJ._PBJ.CastUuid(super.DestinationSpace); | ||
244 | } else { | ||
245 | return PBJ._PBJ.CastUuid(); | ||
246 | } | ||
247 | } | ||
248 | } | ||
249 | public const int IdFieldTag=7; | ||
250 | public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } | ||
251 | public long Id{ get { | ||
252 | if (HasId) { | ||
253 | return PBJ._PBJ.CastInt64(super.Id); | ||
254 | } else { | ||
255 | return PBJ._PBJ.CastInt64(); | ||
256 | } | ||
257 | } | ||
258 | } | ||
259 | public const int ReplyIdFieldTag=8; | ||
260 | public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } | ||
261 | public long ReplyId{ get { | ||
262 | if (HasReplyId) { | ||
263 | return PBJ._PBJ.CastInt64(super.ReplyId); | ||
264 | } else { | ||
265 | return PBJ._PBJ.CastInt64(); | ||
266 | } | ||
267 | } | ||
268 | } | ||
269 | public const int ReturnStatusFieldTag=1792; | ||
270 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
271 | public Types.ReturnStatus ReturnStatus{ get { | ||
272 | if (HasReturnStatus) { | ||
273 | return (Types.ReturnStatus)super.ReturnStatus; | ||
274 | } else { | ||
275 | return new Types.ReturnStatus(); | ||
276 | } | ||
277 | } | ||
278 | } | ||
279 | public const int MessageNamesFieldTag=9; | ||
280 | public int MessageNamesCount { get { return super.MessageNamesCount;} } | ||
281 | public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} | ||
282 | public string MessageNames(int index) { | ||
283 | return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); | ||
284 | } | ||
285 | public const int MessageArgumentsFieldTag=10; | ||
286 | public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } | ||
287 | public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} | ||
288 | public pb::ByteString MessageArguments(int index) { | ||
289 | return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); | ||
290 | } | ||
291 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
292 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
293 | public static Builder CreateBuilder() { return new Builder(); } | ||
294 | public static Builder CreateBuilder(ReadOnlyMessage prototype) { | ||
295 | return (Builder)new Builder().MergeFrom(prototype); | ||
296 | } | ||
297 | public static ReadOnlyMessage ParseFrom(pb::ByteString data) { | ||
298 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); | ||
299 | } | ||
300 | public static ReadOnlyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
301 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); | ||
302 | } | ||
303 | public static ReadOnlyMessage ParseFrom(byte[] data) { | ||
304 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); | ||
305 | } | ||
306 | public static ReadOnlyMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
307 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); | ||
308 | } | ||
309 | public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data) { | ||
310 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); | ||
311 | } | ||
312 | public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
313 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); | ||
314 | } | ||
315 | public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data) { | ||
316 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data)); | ||
317 | } | ||
318 | public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
319 | return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er)); | ||
320 | } | ||
321 | protected override bool _HasAllPBJFields{ get { | ||
322 | return true | ||
323 | ; | ||
324 | } } | ||
325 | public bool IsInitialized { get { | ||
326 | return super.IsInitialized&&_HasAllPBJFields; | ||
327 | } } | ||
328 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
329 | protected override bool _HasAllPBJFields{ get { | ||
330 | return true | ||
331 | ; | ||
332 | } } | ||
333 | public bool IsInitialized { get { | ||
334 | return super.IsInitialized&&_HasAllPBJFields; | ||
335 | } } | ||
336 | protected _PBJ_Internal.ReadOnlyMessage.Builder super; | ||
337 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
338 | public _PBJ_Internal.ReadOnlyMessage.Builder _PBJSuper{ get { return super;} } | ||
339 | public Builder() {super = new _PBJ_Internal.ReadOnlyMessage.Builder();} | ||
340 | public Builder(_PBJ_Internal.ReadOnlyMessage.Builder other) { | ||
341 | super=other; | ||
342 | } | ||
343 | public Builder Clone() {return new Builder(super.Clone());} | ||
344 | public Builder MergeFrom(ReadOnlyMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
345 | public Builder Clear() {super.Clear();return this;} | ||
346 | public ReadOnlyMessage BuildPartial() {return new ReadOnlyMessage(super.BuildPartial());} | ||
347 | public ReadOnlyMessage Build() {if (_HasAllPBJFields) return new ReadOnlyMessage(super.Build());return null;} | ||
348 | public pbd::MessageDescriptor DescriptorForType { | ||
349 | get { return ReadOnlyMessage.Descriptor; } } | ||
350 | public Builder ClearSourceObject() { super.ClearSourceObject();return this;} | ||
351 | public const int SourceObjectFieldTag=1; | ||
352 | public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} } | ||
353 | public PBJ.UUID SourceObject{ get { | ||
354 | if (HasSourceObject) { | ||
355 | return PBJ._PBJ.CastUuid(super.SourceObject); | ||
356 | } else { | ||
357 | return PBJ._PBJ.CastUuid(); | ||
358 | } | ||
359 | } | ||
360 | set { | ||
361 | super.SourceObject=(PBJ._PBJ.Construct(value)); | ||
362 | } | ||
363 | } | ||
364 | public Builder ClearSourcePort() { super.ClearSourcePort();return this;} | ||
365 | public const int SourcePortFieldTag=3; | ||
366 | public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} } | ||
367 | public uint SourcePort{ get { | ||
368 | if (HasSourcePort) { | ||
369 | return PBJ._PBJ.CastUint32(super.SourcePort); | ||
370 | } else { | ||
371 | return PBJ._PBJ.CastUint32(); | ||
372 | } | ||
373 | } | ||
374 | set { | ||
375 | super.SourcePort=(PBJ._PBJ.Construct(value)); | ||
376 | } | ||
377 | } | ||
378 | public Builder ClearSourceSpace() { super.ClearSourceSpace();return this;} | ||
379 | public const int SourceSpaceFieldTag=1536; | ||
380 | public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} } | ||
381 | public PBJ.UUID SourceSpace{ get { | ||
382 | if (HasSourceSpace) { | ||
383 | return PBJ._PBJ.CastUuid(super.SourceSpace); | ||
384 | } else { | ||
385 | return PBJ._PBJ.CastUuid(); | ||
386 | } | ||
387 | } | ||
388 | set { | ||
389 | super.SourceSpace=(PBJ._PBJ.Construct(value)); | ||
390 | } | ||
391 | } | ||
392 | public Builder ClearDestinationObject() { super.ClearDestinationObject();return this;} | ||
393 | public const int DestinationObjectFieldTag=2; | ||
394 | public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} } | ||
395 | public PBJ.UUID DestinationObject{ get { | ||
396 | if (HasDestinationObject) { | ||
397 | return PBJ._PBJ.CastUuid(super.DestinationObject); | ||
398 | } else { | ||
399 | return PBJ._PBJ.CastUuid(); | ||
400 | } | ||
401 | } | ||
402 | set { | ||
403 | super.DestinationObject=(PBJ._PBJ.Construct(value)); | ||
404 | } | ||
405 | } | ||
406 | public Builder ClearDestinationPort() { super.ClearDestinationPort();return this;} | ||
407 | public const int DestinationPortFieldTag=4; | ||
408 | public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} } | ||
409 | public uint DestinationPort{ get { | ||
410 | if (HasDestinationPort) { | ||
411 | return PBJ._PBJ.CastUint32(super.DestinationPort); | ||
412 | } else { | ||
413 | return PBJ._PBJ.CastUint32(); | ||
414 | } | ||
415 | } | ||
416 | set { | ||
417 | super.DestinationPort=(PBJ._PBJ.Construct(value)); | ||
418 | } | ||
419 | } | ||
420 | public Builder ClearDestinationSpace() { super.ClearDestinationSpace();return this;} | ||
421 | public const int DestinationSpaceFieldTag=1537; | ||
422 | public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} } | ||
423 | public PBJ.UUID DestinationSpace{ get { | ||
424 | if (HasDestinationSpace) { | ||
425 | return PBJ._PBJ.CastUuid(super.DestinationSpace); | ||
426 | } else { | ||
427 | return PBJ._PBJ.CastUuid(); | ||
428 | } | ||
429 | } | ||
430 | set { | ||
431 | super.DestinationSpace=(PBJ._PBJ.Construct(value)); | ||
432 | } | ||
433 | } | ||
434 | public Builder ClearId() { super.ClearId();return this;} | ||
435 | public const int IdFieldTag=7; | ||
436 | public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} } | ||
437 | public long Id{ get { | ||
438 | if (HasId) { | ||
439 | return PBJ._PBJ.CastInt64(super.Id); | ||
440 | } else { | ||
441 | return PBJ._PBJ.CastInt64(); | ||
442 | } | ||
443 | } | ||
444 | set { | ||
445 | super.Id=(PBJ._PBJ.Construct(value)); | ||
446 | } | ||
447 | } | ||
448 | public Builder ClearReplyId() { super.ClearReplyId();return this;} | ||
449 | public const int ReplyIdFieldTag=8; | ||
450 | public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} } | ||
451 | public long ReplyId{ get { | ||
452 | if (HasReplyId) { | ||
453 | return PBJ._PBJ.CastInt64(super.ReplyId); | ||
454 | } else { | ||
455 | return PBJ._PBJ.CastInt64(); | ||
456 | } | ||
457 | } | ||
458 | set { | ||
459 | super.ReplyId=(PBJ._PBJ.Construct(value)); | ||
460 | } | ||
461 | } | ||
462 | public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;} | ||
463 | public const int ReturnStatusFieldTag=1792; | ||
464 | public bool HasReturnStatus{ get {return super.HasReturnStatus;} } | ||
465 | public Types.ReturnStatus ReturnStatus{ get { | ||
466 | if (HasReturnStatus) { | ||
467 | return (Types.ReturnStatus)super.ReturnStatus; | ||
468 | } else { | ||
469 | return new Types.ReturnStatus(); | ||
470 | } | ||
471 | } | ||
472 | set { | ||
473 | super.ReturnStatus=((_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus)value); | ||
474 | } | ||
475 | } | ||
476 | public Builder ClearMessageNames() { super.ClearMessageNames();return this;} | ||
477 | public Builder SetMessageNames(int index, string value) { | ||
478 | super.SetMessageNames(index,PBJ._PBJ.Construct(value)); | ||
479 | return this; | ||
480 | } | ||
481 | public const int MessageNamesFieldTag=9; | ||
482 | public int MessageNamesCount { get { return super.MessageNamesCount;} } | ||
483 | public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));} | ||
484 | public string MessageNames(int index) { | ||
485 | return (string)PBJ._PBJ.CastString(super.GetMessageNames(index)); | ||
486 | } | ||
487 | public Builder AddMessageNames(string value) { | ||
488 | super.AddMessageNames(PBJ._PBJ.Construct(value)); | ||
489 | return this; | ||
490 | } | ||
491 | public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;} | ||
492 | public Builder SetMessageArguments(int index, pb::ByteString value) { | ||
493 | super.SetMessageArguments(index,PBJ._PBJ.Construct(value)); | ||
494 | return this; | ||
495 | } | ||
496 | public const int MessageArgumentsFieldTag=10; | ||
497 | public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} } | ||
498 | public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));} | ||
499 | public pb::ByteString MessageArguments(int index) { | ||
500 | return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index)); | ||
501 | } | ||
502 | public Builder AddMessageArguments(pb::ByteString value) { | ||
503 | super.AddMessageArguments(PBJ._PBJ.Construct(value)); | ||
504 | return this; | ||
505 | } | ||
506 | } | ||
507 | } | ||
508 | } | ||
509 | namespace Sirikata.Protocol { | ||
510 | public class SpaceServices : PBJ.IMessage { | ||
511 | protected _PBJ_Internal.SpaceServices super; | ||
512 | public _PBJ_Internal.SpaceServices _PBJSuper{ get { return super;} } | ||
513 | public SpaceServices() { | ||
514 | super=new _PBJ_Internal.SpaceServices(); | ||
515 | } | ||
516 | public SpaceServices(_PBJ_Internal.SpaceServices reference) { | ||
517 | super=reference; | ||
518 | } | ||
519 | public static SpaceServices defaultInstance= new SpaceServices (_PBJ_Internal.SpaceServices.DefaultInstance); | ||
520 | public static SpaceServices DefaultInstance{ | ||
521 | get {return defaultInstance;} | ||
522 | } | ||
523 | public static pbd.MessageDescriptor Descriptor { | ||
524 | get { return _PBJ_Internal.SpaceServices.Descriptor; } } | ||
525 | public static class Types { | ||
526 | } | ||
527 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
528 | return false; | ||
529 | } | ||
530 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
531 | return false; | ||
532 | } | ||
533 | public const int RegistrationPortFieldTag=33; | ||
534 | public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} } | ||
535 | public uint RegistrationPort{ get { | ||
536 | if (HasRegistrationPort) { | ||
537 | return PBJ._PBJ.CastUint32(super.RegistrationPort); | ||
538 | } else { | ||
539 | return PBJ._PBJ.CastUint32(); | ||
540 | } | ||
541 | } | ||
542 | } | ||
543 | public const int LocPortFieldTag=34; | ||
544 | public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} } | ||
545 | public uint LocPort{ get { | ||
546 | if (HasLocPort) { | ||
547 | return PBJ._PBJ.CastUint32(super.LocPort); | ||
548 | } else { | ||
549 | return PBJ._PBJ.CastUint32(); | ||
550 | } | ||
551 | } | ||
552 | } | ||
553 | public const int GeomPortFieldTag=35; | ||
554 | public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} } | ||
555 | public uint GeomPort{ get { | ||
556 | if (HasGeomPort) { | ||
557 | return PBJ._PBJ.CastUint32(super.GeomPort); | ||
558 | } else { | ||
559 | return PBJ._PBJ.CastUint32(); | ||
560 | } | ||
561 | } | ||
562 | } | ||
563 | public const int OsegPortFieldTag=36; | ||
564 | public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} } | ||
565 | public uint OsegPort{ get { | ||
566 | if (HasOsegPort) { | ||
567 | return PBJ._PBJ.CastUint32(super.OsegPort); | ||
568 | } else { | ||
569 | return PBJ._PBJ.CastUint32(); | ||
570 | } | ||
571 | } | ||
572 | } | ||
573 | public const int CsegPortFieldTag=37; | ||
574 | public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} } | ||
575 | public uint CsegPort{ get { | ||
576 | if (HasCsegPort) { | ||
577 | return PBJ._PBJ.CastUint32(super.CsegPort); | ||
578 | } else { | ||
579 | return PBJ._PBJ.CastUint32(); | ||
580 | } | ||
581 | } | ||
582 | } | ||
583 | public const int RouterPortFieldTag=38; | ||
584 | public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} } | ||
585 | public uint RouterPort{ get { | ||
586 | if (HasRouterPort) { | ||
587 | return PBJ._PBJ.CastUint32(super.RouterPort); | ||
588 | } else { | ||
589 | return PBJ._PBJ.CastUint32(); | ||
590 | } | ||
591 | } | ||
592 | } | ||
593 | public const int PreConnectionBufferFieldTag=64; | ||
594 | public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} } | ||
595 | public ulong PreConnectionBuffer{ get { | ||
596 | if (HasPreConnectionBuffer) { | ||
597 | return PBJ._PBJ.CastUint64(super.PreConnectionBuffer); | ||
598 | } else { | ||
599 | return PBJ._PBJ.CastUint64(); | ||
600 | } | ||
601 | } | ||
602 | } | ||
603 | public const int MaxPreConnectionMessagesFieldTag=65; | ||
604 | public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} } | ||
605 | public ulong MaxPreConnectionMessages{ get { | ||
606 | if (HasMaxPreConnectionMessages) { | ||
607 | return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages); | ||
608 | } else { | ||
609 | return PBJ._PBJ.CastUint64(); | ||
610 | } | ||
611 | } | ||
612 | } | ||
613 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
614 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
615 | public static Builder CreateBuilder() { return new Builder(); } | ||
616 | public static Builder CreateBuilder(SpaceServices prototype) { | ||
617 | return (Builder)new Builder().MergeFrom(prototype); | ||
618 | } | ||
619 | public static SpaceServices ParseFrom(pb::ByteString data) { | ||
620 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); | ||
621 | } | ||
622 | public static SpaceServices ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
623 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); | ||
624 | } | ||
625 | public static SpaceServices ParseFrom(byte[] data) { | ||
626 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); | ||
627 | } | ||
628 | public static SpaceServices ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
629 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); | ||
630 | } | ||
631 | public static SpaceServices ParseFrom(global::System.IO.Stream data) { | ||
632 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); | ||
633 | } | ||
634 | public static SpaceServices ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
635 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); | ||
636 | } | ||
637 | public static SpaceServices ParseFrom(pb::CodedInputStream data) { | ||
638 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data)); | ||
639 | } | ||
640 | public static SpaceServices ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
641 | return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er)); | ||
642 | } | ||
643 | protected override bool _HasAllPBJFields{ get { | ||
644 | return true | ||
645 | ; | ||
646 | } } | ||
647 | public bool IsInitialized { get { | ||
648 | return super.IsInitialized&&_HasAllPBJFields; | ||
649 | } } | ||
650 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
651 | protected override bool _HasAllPBJFields{ get { | ||
652 | return true | ||
653 | ; | ||
654 | } } | ||
655 | public bool IsInitialized { get { | ||
656 | return super.IsInitialized&&_HasAllPBJFields; | ||
657 | } } | ||
658 | protected _PBJ_Internal.SpaceServices.Builder super; | ||
659 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
660 | public _PBJ_Internal.SpaceServices.Builder _PBJSuper{ get { return super;} } | ||
661 | public Builder() {super = new _PBJ_Internal.SpaceServices.Builder();} | ||
662 | public Builder(_PBJ_Internal.SpaceServices.Builder other) { | ||
663 | super=other; | ||
664 | } | ||
665 | public Builder Clone() {return new Builder(super.Clone());} | ||
666 | public Builder MergeFrom(SpaceServices prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
667 | public Builder Clear() {super.Clear();return this;} | ||
668 | public SpaceServices BuildPartial() {return new SpaceServices(super.BuildPartial());} | ||
669 | public SpaceServices Build() {if (_HasAllPBJFields) return new SpaceServices(super.Build());return null;} | ||
670 | public pbd::MessageDescriptor DescriptorForType { | ||
671 | get { return SpaceServices.Descriptor; } } | ||
672 | public Builder ClearRegistrationPort() { super.ClearRegistrationPort();return this;} | ||
673 | public const int RegistrationPortFieldTag=33; | ||
674 | public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} } | ||
675 | public uint RegistrationPort{ get { | ||
676 | if (HasRegistrationPort) { | ||
677 | return PBJ._PBJ.CastUint32(super.RegistrationPort); | ||
678 | } else { | ||
679 | return PBJ._PBJ.CastUint32(); | ||
680 | } | ||
681 | } | ||
682 | set { | ||
683 | super.RegistrationPort=(PBJ._PBJ.Construct(value)); | ||
684 | } | ||
685 | } | ||
686 | public Builder ClearLocPort() { super.ClearLocPort();return this;} | ||
687 | public const int LocPortFieldTag=34; | ||
688 | public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} } | ||
689 | public uint LocPort{ get { | ||
690 | if (HasLocPort) { | ||
691 | return PBJ._PBJ.CastUint32(super.LocPort); | ||
692 | } else { | ||
693 | return PBJ._PBJ.CastUint32(); | ||
694 | } | ||
695 | } | ||
696 | set { | ||
697 | super.LocPort=(PBJ._PBJ.Construct(value)); | ||
698 | } | ||
699 | } | ||
700 | public Builder ClearGeomPort() { super.ClearGeomPort();return this;} | ||
701 | public const int GeomPortFieldTag=35; | ||
702 | public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} } | ||
703 | public uint GeomPort{ get { | ||
704 | if (HasGeomPort) { | ||
705 | return PBJ._PBJ.CastUint32(super.GeomPort); | ||
706 | } else { | ||
707 | return PBJ._PBJ.CastUint32(); | ||
708 | } | ||
709 | } | ||
710 | set { | ||
711 | super.GeomPort=(PBJ._PBJ.Construct(value)); | ||
712 | } | ||
713 | } | ||
714 | public Builder ClearOsegPort() { super.ClearOsegPort();return this;} | ||
715 | public const int OsegPortFieldTag=36; | ||
716 | public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} } | ||
717 | public uint OsegPort{ get { | ||
718 | if (HasOsegPort) { | ||
719 | return PBJ._PBJ.CastUint32(super.OsegPort); | ||
720 | } else { | ||
721 | return PBJ._PBJ.CastUint32(); | ||
722 | } | ||
723 | } | ||
724 | set { | ||
725 | super.OsegPort=(PBJ._PBJ.Construct(value)); | ||
726 | } | ||
727 | } | ||
728 | public Builder ClearCsegPort() { super.ClearCsegPort();return this;} | ||
729 | public const int CsegPortFieldTag=37; | ||
730 | public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} } | ||
731 | public uint CsegPort{ get { | ||
732 | if (HasCsegPort) { | ||
733 | return PBJ._PBJ.CastUint32(super.CsegPort); | ||
734 | } else { | ||
735 | return PBJ._PBJ.CastUint32(); | ||
736 | } | ||
737 | } | ||
738 | set { | ||
739 | super.CsegPort=(PBJ._PBJ.Construct(value)); | ||
740 | } | ||
741 | } | ||
742 | public Builder ClearRouterPort() { super.ClearRouterPort();return this;} | ||
743 | public const int RouterPortFieldTag=38; | ||
744 | public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} } | ||
745 | public uint RouterPort{ get { | ||
746 | if (HasRouterPort) { | ||
747 | return PBJ._PBJ.CastUint32(super.RouterPort); | ||
748 | } else { | ||
749 | return PBJ._PBJ.CastUint32(); | ||
750 | } | ||
751 | } | ||
752 | set { | ||
753 | super.RouterPort=(PBJ._PBJ.Construct(value)); | ||
754 | } | ||
755 | } | ||
756 | public Builder ClearPreConnectionBuffer() { super.ClearPreConnectionBuffer();return this;} | ||
757 | public const int PreConnectionBufferFieldTag=64; | ||
758 | public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} } | ||
759 | public ulong PreConnectionBuffer{ get { | ||
760 | if (HasPreConnectionBuffer) { | ||
761 | return PBJ._PBJ.CastUint64(super.PreConnectionBuffer); | ||
762 | } else { | ||
763 | return PBJ._PBJ.CastUint64(); | ||
764 | } | ||
765 | } | ||
766 | set { | ||
767 | super.PreConnectionBuffer=(PBJ._PBJ.Construct(value)); | ||
768 | } | ||
769 | } | ||
770 | public Builder ClearMaxPreConnectionMessages() { super.ClearMaxPreConnectionMessages();return this;} | ||
771 | public const int MaxPreConnectionMessagesFieldTag=65; | ||
772 | public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} } | ||
773 | public ulong MaxPreConnectionMessages{ get { | ||
774 | if (HasMaxPreConnectionMessages) { | ||
775 | return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages); | ||
776 | } else { | ||
777 | return PBJ._PBJ.CastUint64(); | ||
778 | } | ||
779 | } | ||
780 | set { | ||
781 | super.MaxPreConnectionMessages=(PBJ._PBJ.Construct(value)); | ||
782 | } | ||
783 | } | ||
784 | } | ||
785 | } | ||
786 | } | ||
787 | namespace Sirikata.Protocol { | ||
788 | public class ObjLoc : PBJ.IMessage { | ||
789 | protected _PBJ_Internal.ObjLoc super; | ||
790 | public _PBJ_Internal.ObjLoc _PBJSuper{ get { return super;} } | ||
791 | public ObjLoc() { | ||
792 | super=new _PBJ_Internal.ObjLoc(); | ||
793 | } | ||
794 | public ObjLoc(_PBJ_Internal.ObjLoc reference) { | ||
795 | super=reference; | ||
796 | } | ||
797 | public static ObjLoc defaultInstance= new ObjLoc (_PBJ_Internal.ObjLoc.DefaultInstance); | ||
798 | public static ObjLoc DefaultInstance{ | ||
799 | get {return defaultInstance;} | ||
800 | } | ||
801 | public static pbd.MessageDescriptor Descriptor { | ||
802 | get { return _PBJ_Internal.ObjLoc.Descriptor; } } | ||
803 | public static class Types { | ||
804 | public enum UpdateFlags { | ||
805 | FORCE=_PBJ_Internal.ObjLoc.Types.UpdateFlags.FORCE | ||
806 | }; | ||
807 | } | ||
808 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
809 | return false; | ||
810 | } | ||
811 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
812 | return false; | ||
813 | } | ||
814 | public const int TimestampFieldTag=2; | ||
815 | public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } | ||
816 | public PBJ.Time Timestamp{ get { | ||
817 | if (HasTimestamp) { | ||
818 | return PBJ._PBJ.CastTime(super.Timestamp); | ||
819 | } else { | ||
820 | return PBJ._PBJ.CastTime(); | ||
821 | } | ||
822 | } | ||
823 | } | ||
824 | public const int PositionFieldTag=3; | ||
825 | public bool HasPosition{ get {return super.PositionCount>=3;} } | ||
826 | public PBJ.Vector3d Position{ get { | ||
827 | int index=0; | ||
828 | if (HasPosition) { | ||
829 | return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2)); | ||
830 | } else { | ||
831 | return PBJ._PBJ.CastVector3d(); | ||
832 | } | ||
833 | } | ||
834 | } | ||
835 | public const int OrientationFieldTag=4; | ||
836 | public bool HasOrientation{ get {return super.OrientationCount>=3;} } | ||
837 | public PBJ.Quaternion Orientation{ get { | ||
838 | int index=0; | ||
839 | if (HasOrientation) { | ||
840 | return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2)); | ||
841 | } else { | ||
842 | return PBJ._PBJ.CastQuaternion(); | ||
843 | } | ||
844 | } | ||
845 | } | ||
846 | public const int VelocityFieldTag=5; | ||
847 | public bool HasVelocity{ get {return super.VelocityCount>=3;} } | ||
848 | public PBJ.Vector3f Velocity{ get { | ||
849 | int index=0; | ||
850 | if (HasVelocity) { | ||
851 | return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2)); | ||
852 | } else { | ||
853 | return PBJ._PBJ.CastVector3f(); | ||
854 | } | ||
855 | } | ||
856 | } | ||
857 | public const int RotationalAxisFieldTag=7; | ||
858 | public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} } | ||
859 | public PBJ.Vector3f RotationalAxis{ get { | ||
860 | int index=0; | ||
861 | if (HasRotationalAxis) { | ||
862 | return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1)); | ||
863 | } else { | ||
864 | return PBJ._PBJ.CastNormal(); | ||
865 | } | ||
866 | } | ||
867 | } | ||
868 | public const int AngularSpeedFieldTag=8; | ||
869 | public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} } | ||
870 | public float AngularSpeed{ get { | ||
871 | if (HasAngularSpeed) { | ||
872 | return PBJ._PBJ.CastFloat(super.AngularSpeed); | ||
873 | } else { | ||
874 | return PBJ._PBJ.CastFloat(); | ||
875 | } | ||
876 | } | ||
877 | } | ||
878 | public const int UpdateFlagsFieldTag=6; | ||
879 | public bool HasUpdateFlags { get { | ||
880 | if (!super.HasUpdateFlags) return false; | ||
881 | return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); | ||
882 | } } | ||
883 | public byte UpdateFlags{ get { | ||
884 | if (HasUpdateFlags) { | ||
885 | return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); | ||
886 | } else { | ||
887 | return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE); | ||
888 | } | ||
889 | } | ||
890 | } | ||
891 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
892 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
893 | public static Builder CreateBuilder() { return new Builder(); } | ||
894 | public static Builder CreateBuilder(ObjLoc prototype) { | ||
895 | return (Builder)new Builder().MergeFrom(prototype); | ||
896 | } | ||
897 | public static ObjLoc ParseFrom(pb::ByteString data) { | ||
898 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); | ||
899 | } | ||
900 | public static ObjLoc ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
901 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); | ||
902 | } | ||
903 | public static ObjLoc ParseFrom(byte[] data) { | ||
904 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); | ||
905 | } | ||
906 | public static ObjLoc ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
907 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); | ||
908 | } | ||
909 | public static ObjLoc ParseFrom(global::System.IO.Stream data) { | ||
910 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); | ||
911 | } | ||
912 | public static ObjLoc ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
913 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); | ||
914 | } | ||
915 | public static ObjLoc ParseFrom(pb::CodedInputStream data) { | ||
916 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data)); | ||
917 | } | ||
918 | public static ObjLoc ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
919 | return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er)); | ||
920 | } | ||
921 | protected override bool _HasAllPBJFields{ get { | ||
922 | return true | ||
923 | ; | ||
924 | } } | ||
925 | public bool IsInitialized { get { | ||
926 | return super.IsInitialized&&_HasAllPBJFields; | ||
927 | } } | ||
928 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
929 | protected override bool _HasAllPBJFields{ get { | ||
930 | return true | ||
931 | ; | ||
932 | } } | ||
933 | public bool IsInitialized { get { | ||
934 | return super.IsInitialized&&_HasAllPBJFields; | ||
935 | } } | ||
936 | protected _PBJ_Internal.ObjLoc.Builder super; | ||
937 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
938 | public _PBJ_Internal.ObjLoc.Builder _PBJSuper{ get { return super;} } | ||
939 | public Builder() {super = new _PBJ_Internal.ObjLoc.Builder();} | ||
940 | public Builder(_PBJ_Internal.ObjLoc.Builder other) { | ||
941 | super=other; | ||
942 | } | ||
943 | public Builder Clone() {return new Builder(super.Clone());} | ||
944 | public Builder MergeFrom(ObjLoc prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
945 | public Builder Clear() {super.Clear();return this;} | ||
946 | public ObjLoc BuildPartial() {return new ObjLoc(super.BuildPartial());} | ||
947 | public ObjLoc Build() {if (_HasAllPBJFields) return new ObjLoc(super.Build());return null;} | ||
948 | public pbd::MessageDescriptor DescriptorForType { | ||
949 | get { return ObjLoc.Descriptor; } } | ||
950 | public Builder ClearTimestamp() { super.ClearTimestamp();return this;} | ||
951 | public const int TimestampFieldTag=2; | ||
952 | public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} } | ||
953 | public PBJ.Time Timestamp{ get { | ||
954 | if (HasTimestamp) { | ||
955 | return PBJ._PBJ.CastTime(super.Timestamp); | ||
956 | } else { | ||
957 | return PBJ._PBJ.CastTime(); | ||
958 | } | ||
959 | } | ||
960 | set { | ||
961 | super.Timestamp=(PBJ._PBJ.Construct(value)); | ||
962 | } | ||
963 | } | ||
964 | public Builder ClearPosition() { super.ClearPosition();return this;} | ||
965 | public const int PositionFieldTag=3; | ||
966 | public bool HasPosition{ get {return super.PositionCount>=3;} } | ||
967 | public PBJ.Vector3d Position{ get { | ||
968 | int index=0; | ||
969 | if (HasPosition) { | ||
970 | return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2)); | ||
971 | } else { | ||
972 | return PBJ._PBJ.CastVector3d(); | ||
973 | } | ||
974 | } | ||
975 | set { | ||
976 | super.ClearPosition(); | ||
977 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
978 | super.AddPosition(_PBJtempArray[0]); | ||
979 | super.AddPosition(_PBJtempArray[1]); | ||
980 | super.AddPosition(_PBJtempArray[2]); | ||
981 | } | ||
982 | } | ||
983 | public Builder ClearOrientation() { super.ClearOrientation();return this;} | ||
984 | public const int OrientationFieldTag=4; | ||
985 | public bool HasOrientation{ get {return super.OrientationCount>=3;} } | ||
986 | public PBJ.Quaternion Orientation{ get { | ||
987 | int index=0; | ||
988 | if (HasOrientation) { | ||
989 | return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2)); | ||
990 | } else { | ||
991 | return PBJ._PBJ.CastQuaternion(); | ||
992 | } | ||
993 | } | ||
994 | set { | ||
995 | super.ClearOrientation(); | ||
996 | float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value); | ||
997 | super.AddOrientation(_PBJtempArray[0]); | ||
998 | super.AddOrientation(_PBJtempArray[1]); | ||
999 | super.AddOrientation(_PBJtempArray[2]); | ||
1000 | } | ||
1001 | } | ||
1002 | public Builder ClearVelocity() { super.ClearVelocity();return this;} | ||
1003 | public const int VelocityFieldTag=5; | ||
1004 | public bool HasVelocity{ get {return super.VelocityCount>=3;} } | ||
1005 | public PBJ.Vector3f Velocity{ get { | ||
1006 | int index=0; | ||
1007 | if (HasVelocity) { | ||
1008 | return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2)); | ||
1009 | } else { | ||
1010 | return PBJ._PBJ.CastVector3f(); | ||
1011 | } | ||
1012 | } | ||
1013 | set { | ||
1014 | super.ClearVelocity(); | ||
1015 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
1016 | super.AddVelocity(_PBJtempArray[0]); | ||
1017 | super.AddVelocity(_PBJtempArray[1]); | ||
1018 | super.AddVelocity(_PBJtempArray[2]); | ||
1019 | } | ||
1020 | } | ||
1021 | public Builder ClearRotationalAxis() { super.ClearRotationalAxis();return this;} | ||
1022 | public const int RotationalAxisFieldTag=7; | ||
1023 | public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} } | ||
1024 | public PBJ.Vector3f RotationalAxis{ get { | ||
1025 | int index=0; | ||
1026 | if (HasRotationalAxis) { | ||
1027 | return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1)); | ||
1028 | } else { | ||
1029 | return PBJ._PBJ.CastNormal(); | ||
1030 | } | ||
1031 | } | ||
1032 | set { | ||
1033 | super.ClearRotationalAxis(); | ||
1034 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
1035 | super.AddRotationalAxis(_PBJtempArray[0]); | ||
1036 | super.AddRotationalAxis(_PBJtempArray[1]); | ||
1037 | } | ||
1038 | } | ||
1039 | public Builder ClearAngularSpeed() { super.ClearAngularSpeed();return this;} | ||
1040 | public const int AngularSpeedFieldTag=8; | ||
1041 | public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} } | ||
1042 | public float AngularSpeed{ get { | ||
1043 | if (HasAngularSpeed) { | ||
1044 | return PBJ._PBJ.CastFloat(super.AngularSpeed); | ||
1045 | } else { | ||
1046 | return PBJ._PBJ.CastFloat(); | ||
1047 | } | ||
1048 | } | ||
1049 | set { | ||
1050 | super.AngularSpeed=(PBJ._PBJ.Construct(value)); | ||
1051 | } | ||
1052 | } | ||
1053 | public Builder ClearUpdateFlags() { super.ClearUpdateFlags();return this;} | ||
1054 | public const int UpdateFlagsFieldTag=6; | ||
1055 | public bool HasUpdateFlags { get { | ||
1056 | if (!super.HasUpdateFlags) return false; | ||
1057 | return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); | ||
1058 | } } | ||
1059 | public byte UpdateFlags{ get { | ||
1060 | if (HasUpdateFlags) { | ||
1061 | return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE); | ||
1062 | } else { | ||
1063 | return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE); | ||
1064 | } | ||
1065 | } | ||
1066 | set { | ||
1067 | super.UpdateFlags=((value)); | ||
1068 | } | ||
1069 | } | ||
1070 | } | ||
1071 | } | ||
1072 | } | ||
1073 | namespace Sirikata.Protocol { | ||
1074 | public class LocRequest : PBJ.IMessage { | ||
1075 | protected _PBJ_Internal.LocRequest super; | ||
1076 | public _PBJ_Internal.LocRequest _PBJSuper{ get { return super;} } | ||
1077 | public LocRequest() { | ||
1078 | super=new _PBJ_Internal.LocRequest(); | ||
1079 | } | ||
1080 | public LocRequest(_PBJ_Internal.LocRequest reference) { | ||
1081 | super=reference; | ||
1082 | } | ||
1083 | public static LocRequest defaultInstance= new LocRequest (_PBJ_Internal.LocRequest.DefaultInstance); | ||
1084 | public static LocRequest DefaultInstance{ | ||
1085 | get {return defaultInstance;} | ||
1086 | } | ||
1087 | public static pbd.MessageDescriptor Descriptor { | ||
1088 | get { return _PBJ_Internal.LocRequest.Descriptor; } } | ||
1089 | public static class Types { | ||
1090 | public enum Fields { | ||
1091 | POSITION=_PBJ_Internal.LocRequest.Types.Fields.POSITION, | ||
1092 | ORIENTATION=_PBJ_Internal.LocRequest.Types.Fields.ORIENTATION, | ||
1093 | VELOCITY=_PBJ_Internal.LocRequest.Types.Fields.VELOCITY, | ||
1094 | ROTATIONAL_AXIS=_PBJ_Internal.LocRequest.Types.Fields.ROTATIONAL_AXIS, | ||
1095 | ANGULAR_SPEED=_PBJ_Internal.LocRequest.Types.Fields.ANGULAR_SPEED | ||
1096 | }; | ||
1097 | } | ||
1098 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1099 | return false; | ||
1100 | } | ||
1101 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1102 | return false; | ||
1103 | } | ||
1104 | public const int RequestedFieldsFieldTag=2; | ||
1105 | public bool HasRequestedFields { get { | ||
1106 | if (!super.HasRequestedFields) return false; | ||
1107 | return PBJ._PBJ.ValidateFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); | ||
1108 | } } | ||
1109 | public uint RequestedFields{ get { | ||
1110 | if (HasRequestedFields) { | ||
1111 | return (uint)PBJ._PBJ.CastFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); | ||
1112 | } else { | ||
1113 | return (uint)PBJ._PBJ.CastFlags((ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); | ||
1114 | } | ||
1115 | } | ||
1116 | } | ||
1117 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1118 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1119 | public static Builder CreateBuilder() { return new Builder(); } | ||
1120 | public static Builder CreateBuilder(LocRequest prototype) { | ||
1121 | return (Builder)new Builder().MergeFrom(prototype); | ||
1122 | } | ||
1123 | public static LocRequest ParseFrom(pb::ByteString data) { | ||
1124 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); | ||
1125 | } | ||
1126 | public static LocRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1127 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); | ||
1128 | } | ||
1129 | public static LocRequest ParseFrom(byte[] data) { | ||
1130 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); | ||
1131 | } | ||
1132 | public static LocRequest ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1133 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); | ||
1134 | } | ||
1135 | public static LocRequest ParseFrom(global::System.IO.Stream data) { | ||
1136 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); | ||
1137 | } | ||
1138 | public static LocRequest ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1139 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); | ||
1140 | } | ||
1141 | public static LocRequest ParseFrom(pb::CodedInputStream data) { | ||
1142 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data)); | ||
1143 | } | ||
1144 | public static LocRequest ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1145 | return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er)); | ||
1146 | } | ||
1147 | protected override bool _HasAllPBJFields{ get { | ||
1148 | return true | ||
1149 | ; | ||
1150 | } } | ||
1151 | public bool IsInitialized { get { | ||
1152 | return super.IsInitialized&&_HasAllPBJFields; | ||
1153 | } } | ||
1154 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1155 | protected override bool _HasAllPBJFields{ get { | ||
1156 | return true | ||
1157 | ; | ||
1158 | } } | ||
1159 | public bool IsInitialized { get { | ||
1160 | return super.IsInitialized&&_HasAllPBJFields; | ||
1161 | } } | ||
1162 | protected _PBJ_Internal.LocRequest.Builder super; | ||
1163 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1164 | public _PBJ_Internal.LocRequest.Builder _PBJSuper{ get { return super;} } | ||
1165 | public Builder() {super = new _PBJ_Internal.LocRequest.Builder();} | ||
1166 | public Builder(_PBJ_Internal.LocRequest.Builder other) { | ||
1167 | super=other; | ||
1168 | } | ||
1169 | public Builder Clone() {return new Builder(super.Clone());} | ||
1170 | public Builder MergeFrom(LocRequest prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1171 | public Builder Clear() {super.Clear();return this;} | ||
1172 | public LocRequest BuildPartial() {return new LocRequest(super.BuildPartial());} | ||
1173 | public LocRequest Build() {if (_HasAllPBJFields) return new LocRequest(super.Build());return null;} | ||
1174 | public pbd::MessageDescriptor DescriptorForType { | ||
1175 | get { return LocRequest.Descriptor; } } | ||
1176 | public Builder ClearRequestedFields() { super.ClearRequestedFields();return this;} | ||
1177 | public const int RequestedFieldsFieldTag=2; | ||
1178 | public bool HasRequestedFields { get { | ||
1179 | if (!super.HasRequestedFields) return false; | ||
1180 | return PBJ._PBJ.ValidateFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); | ||
1181 | } } | ||
1182 | public uint RequestedFields{ get { | ||
1183 | if (HasRequestedFields) { | ||
1184 | return (uint)PBJ._PBJ.CastFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); | ||
1185 | } else { | ||
1186 | return (uint)PBJ._PBJ.CastFlags((ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED); | ||
1187 | } | ||
1188 | } | ||
1189 | set { | ||
1190 | super.RequestedFields=((value)); | ||
1191 | } | ||
1192 | } | ||
1193 | } | ||
1194 | } | ||
1195 | } | ||
1196 | namespace Sirikata.Protocol { | ||
1197 | public class NewObj : PBJ.IMessage { | ||
1198 | protected _PBJ_Internal.NewObj super; | ||
1199 | public _PBJ_Internal.NewObj _PBJSuper{ get { return super;} } | ||
1200 | public NewObj() { | ||
1201 | super=new _PBJ_Internal.NewObj(); | ||
1202 | } | ||
1203 | public NewObj(_PBJ_Internal.NewObj reference) { | ||
1204 | super=reference; | ||
1205 | } | ||
1206 | public static NewObj defaultInstance= new NewObj (_PBJ_Internal.NewObj.DefaultInstance); | ||
1207 | public static NewObj DefaultInstance{ | ||
1208 | get {return defaultInstance;} | ||
1209 | } | ||
1210 | public static pbd.MessageDescriptor Descriptor { | ||
1211 | get { return _PBJ_Internal.NewObj.Descriptor; } } | ||
1212 | public static class Types { | ||
1213 | } | ||
1214 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1215 | return false; | ||
1216 | } | ||
1217 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1218 | return false; | ||
1219 | } | ||
1220 | public const int ObjectUuidEvidenceFieldTag=2; | ||
1221 | public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } | ||
1222 | public PBJ.UUID ObjectUuidEvidence{ get { | ||
1223 | if (HasObjectUuidEvidence) { | ||
1224 | return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); | ||
1225 | } else { | ||
1226 | return PBJ._PBJ.CastUuid(); | ||
1227 | } | ||
1228 | } | ||
1229 | } | ||
1230 | public const int RequestedObjectLocFieldTag=3; | ||
1231 | public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } | ||
1232 | public ObjLoc RequestedObjectLoc{ get { | ||
1233 | if (HasRequestedObjectLoc) { | ||
1234 | return new ObjLoc(super.RequestedObjectLoc); | ||
1235 | } else { | ||
1236 | return new ObjLoc(); | ||
1237 | } | ||
1238 | } | ||
1239 | } | ||
1240 | public const int BoundingSphereFieldTag=4; | ||
1241 | public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } | ||
1242 | public PBJ.BoundingSphere3f BoundingSphere{ get { | ||
1243 | int index=0; | ||
1244 | if (HasBoundingSphere) { | ||
1245 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); | ||
1246 | } else { | ||
1247 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
1248 | } | ||
1249 | } | ||
1250 | } | ||
1251 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1252 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1253 | public static Builder CreateBuilder() { return new Builder(); } | ||
1254 | public static Builder CreateBuilder(NewObj prototype) { | ||
1255 | return (Builder)new Builder().MergeFrom(prototype); | ||
1256 | } | ||
1257 | public static NewObj ParseFrom(pb::ByteString data) { | ||
1258 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); | ||
1259 | } | ||
1260 | public static NewObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1261 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); | ||
1262 | } | ||
1263 | public static NewObj ParseFrom(byte[] data) { | ||
1264 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); | ||
1265 | } | ||
1266 | public static NewObj ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1267 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); | ||
1268 | } | ||
1269 | public static NewObj ParseFrom(global::System.IO.Stream data) { | ||
1270 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); | ||
1271 | } | ||
1272 | public static NewObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1273 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); | ||
1274 | } | ||
1275 | public static NewObj ParseFrom(pb::CodedInputStream data) { | ||
1276 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data)); | ||
1277 | } | ||
1278 | public static NewObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1279 | return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er)); | ||
1280 | } | ||
1281 | protected override bool _HasAllPBJFields{ get { | ||
1282 | return true | ||
1283 | ; | ||
1284 | } } | ||
1285 | public bool IsInitialized { get { | ||
1286 | return super.IsInitialized&&_HasAllPBJFields; | ||
1287 | } } | ||
1288 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1289 | protected override bool _HasAllPBJFields{ get { | ||
1290 | return true | ||
1291 | ; | ||
1292 | } } | ||
1293 | public bool IsInitialized { get { | ||
1294 | return super.IsInitialized&&_HasAllPBJFields; | ||
1295 | } } | ||
1296 | protected _PBJ_Internal.NewObj.Builder super; | ||
1297 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1298 | public _PBJ_Internal.NewObj.Builder _PBJSuper{ get { return super;} } | ||
1299 | public Builder() {super = new _PBJ_Internal.NewObj.Builder();} | ||
1300 | public Builder(_PBJ_Internal.NewObj.Builder other) { | ||
1301 | super=other; | ||
1302 | } | ||
1303 | public Builder Clone() {return new Builder(super.Clone());} | ||
1304 | public Builder MergeFrom(NewObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1305 | public Builder Clear() {super.Clear();return this;} | ||
1306 | public NewObj BuildPartial() {return new NewObj(super.BuildPartial());} | ||
1307 | public NewObj Build() {if (_HasAllPBJFields) return new NewObj(super.Build());return null;} | ||
1308 | public pbd::MessageDescriptor DescriptorForType { | ||
1309 | get { return NewObj.Descriptor; } } | ||
1310 | public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;} | ||
1311 | public const int ObjectUuidEvidenceFieldTag=2; | ||
1312 | public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } | ||
1313 | public PBJ.UUID ObjectUuidEvidence{ get { | ||
1314 | if (HasObjectUuidEvidence) { | ||
1315 | return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); | ||
1316 | } else { | ||
1317 | return PBJ._PBJ.CastUuid(); | ||
1318 | } | ||
1319 | } | ||
1320 | set { | ||
1321 | super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value)); | ||
1322 | } | ||
1323 | } | ||
1324 | public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;} | ||
1325 | public const int RequestedObjectLocFieldTag=3; | ||
1326 | public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } | ||
1327 | public ObjLoc RequestedObjectLoc{ get { | ||
1328 | if (HasRequestedObjectLoc) { | ||
1329 | return new ObjLoc(super.RequestedObjectLoc); | ||
1330 | } else { | ||
1331 | return new ObjLoc(); | ||
1332 | } | ||
1333 | } | ||
1334 | set { | ||
1335 | super.RequestedObjectLoc=value._PBJSuper; | ||
1336 | } | ||
1337 | } | ||
1338 | public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;} | ||
1339 | public const int BoundingSphereFieldTag=4; | ||
1340 | public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } | ||
1341 | public PBJ.BoundingSphere3f BoundingSphere{ get { | ||
1342 | int index=0; | ||
1343 | if (HasBoundingSphere) { | ||
1344 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); | ||
1345 | } else { | ||
1346 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
1347 | } | ||
1348 | } | ||
1349 | set { | ||
1350 | super.ClearBoundingSphere(); | ||
1351 | float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); | ||
1352 | super.AddBoundingSphere(_PBJtempArray[0]); | ||
1353 | super.AddBoundingSphere(_PBJtempArray[1]); | ||
1354 | super.AddBoundingSphere(_PBJtempArray[2]); | ||
1355 | super.AddBoundingSphere(_PBJtempArray[3]); | ||
1356 | } | ||
1357 | } | ||
1358 | } | ||
1359 | } | ||
1360 | } | ||
1361 | namespace Sirikata.Protocol { | ||
1362 | public class RetObj : PBJ.IMessage { | ||
1363 | protected _PBJ_Internal.RetObj super; | ||
1364 | public _PBJ_Internal.RetObj _PBJSuper{ get { return super;} } | ||
1365 | public RetObj() { | ||
1366 | super=new _PBJ_Internal.RetObj(); | ||
1367 | } | ||
1368 | public RetObj(_PBJ_Internal.RetObj reference) { | ||
1369 | super=reference; | ||
1370 | } | ||
1371 | public static RetObj defaultInstance= new RetObj (_PBJ_Internal.RetObj.DefaultInstance); | ||
1372 | public static RetObj DefaultInstance{ | ||
1373 | get {return defaultInstance;} | ||
1374 | } | ||
1375 | public static pbd.MessageDescriptor Descriptor { | ||
1376 | get { return _PBJ_Internal.RetObj.Descriptor; } } | ||
1377 | public static class Types { | ||
1378 | } | ||
1379 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1380 | return false; | ||
1381 | } | ||
1382 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1383 | return false; | ||
1384 | } | ||
1385 | public const int ObjectReferenceFieldTag=2; | ||
1386 | public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } | ||
1387 | public PBJ.UUID ObjectReference{ get { | ||
1388 | if (HasObjectReference) { | ||
1389 | return PBJ._PBJ.CastUuid(super.ObjectReference); | ||
1390 | } else { | ||
1391 | return PBJ._PBJ.CastUuid(); | ||
1392 | } | ||
1393 | } | ||
1394 | } | ||
1395 | public const int LocationFieldTag=3; | ||
1396 | public bool HasLocation{ get {return super.HasLocation;} } | ||
1397 | public ObjLoc Location{ get { | ||
1398 | if (HasLocation) { | ||
1399 | return new ObjLoc(super.Location); | ||
1400 | } else { | ||
1401 | return new ObjLoc(); | ||
1402 | } | ||
1403 | } | ||
1404 | } | ||
1405 | public const int BoundingSphereFieldTag=4; | ||
1406 | public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } | ||
1407 | public PBJ.BoundingSphere3f BoundingSphere{ get { | ||
1408 | int index=0; | ||
1409 | if (HasBoundingSphere) { | ||
1410 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); | ||
1411 | } else { | ||
1412 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
1413 | } | ||
1414 | } | ||
1415 | } | ||
1416 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1417 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1418 | public static Builder CreateBuilder() { return new Builder(); } | ||
1419 | public static Builder CreateBuilder(RetObj prototype) { | ||
1420 | return (Builder)new Builder().MergeFrom(prototype); | ||
1421 | } | ||
1422 | public static RetObj ParseFrom(pb::ByteString data) { | ||
1423 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); | ||
1424 | } | ||
1425 | public static RetObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1426 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); | ||
1427 | } | ||
1428 | public static RetObj ParseFrom(byte[] data) { | ||
1429 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); | ||
1430 | } | ||
1431 | public static RetObj ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1432 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); | ||
1433 | } | ||
1434 | public static RetObj ParseFrom(global::System.IO.Stream data) { | ||
1435 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); | ||
1436 | } | ||
1437 | public static RetObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1438 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); | ||
1439 | } | ||
1440 | public static RetObj ParseFrom(pb::CodedInputStream data) { | ||
1441 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data)); | ||
1442 | } | ||
1443 | public static RetObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1444 | return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er)); | ||
1445 | } | ||
1446 | protected override bool _HasAllPBJFields{ get { | ||
1447 | return true | ||
1448 | ; | ||
1449 | } } | ||
1450 | public bool IsInitialized { get { | ||
1451 | return super.IsInitialized&&_HasAllPBJFields; | ||
1452 | } } | ||
1453 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1454 | protected override bool _HasAllPBJFields{ get { | ||
1455 | return true | ||
1456 | ; | ||
1457 | } } | ||
1458 | public bool IsInitialized { get { | ||
1459 | return super.IsInitialized&&_HasAllPBJFields; | ||
1460 | } } | ||
1461 | protected _PBJ_Internal.RetObj.Builder super; | ||
1462 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1463 | public _PBJ_Internal.RetObj.Builder _PBJSuper{ get { return super;} } | ||
1464 | public Builder() {super = new _PBJ_Internal.RetObj.Builder();} | ||
1465 | public Builder(_PBJ_Internal.RetObj.Builder other) { | ||
1466 | super=other; | ||
1467 | } | ||
1468 | public Builder Clone() {return new Builder(super.Clone());} | ||
1469 | public Builder MergeFrom(RetObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1470 | public Builder Clear() {super.Clear();return this;} | ||
1471 | public RetObj BuildPartial() {return new RetObj(super.BuildPartial());} | ||
1472 | public RetObj Build() {if (_HasAllPBJFields) return new RetObj(super.Build());return null;} | ||
1473 | public pbd::MessageDescriptor DescriptorForType { | ||
1474 | get { return RetObj.Descriptor; } } | ||
1475 | public Builder ClearObjectReference() { super.ClearObjectReference();return this;} | ||
1476 | public const int ObjectReferenceFieldTag=2; | ||
1477 | public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } | ||
1478 | public PBJ.UUID ObjectReference{ get { | ||
1479 | if (HasObjectReference) { | ||
1480 | return PBJ._PBJ.CastUuid(super.ObjectReference); | ||
1481 | } else { | ||
1482 | return PBJ._PBJ.CastUuid(); | ||
1483 | } | ||
1484 | } | ||
1485 | set { | ||
1486 | super.ObjectReference=(PBJ._PBJ.Construct(value)); | ||
1487 | } | ||
1488 | } | ||
1489 | public Builder ClearLocation() { super.ClearLocation();return this;} | ||
1490 | public const int LocationFieldTag=3; | ||
1491 | public bool HasLocation{ get {return super.HasLocation;} } | ||
1492 | public ObjLoc Location{ get { | ||
1493 | if (HasLocation) { | ||
1494 | return new ObjLoc(super.Location); | ||
1495 | } else { | ||
1496 | return new ObjLoc(); | ||
1497 | } | ||
1498 | } | ||
1499 | set { | ||
1500 | super.Location=value._PBJSuper; | ||
1501 | } | ||
1502 | } | ||
1503 | public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;} | ||
1504 | public const int BoundingSphereFieldTag=4; | ||
1505 | public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } | ||
1506 | public PBJ.BoundingSphere3f BoundingSphere{ get { | ||
1507 | int index=0; | ||
1508 | if (HasBoundingSphere) { | ||
1509 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); | ||
1510 | } else { | ||
1511 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
1512 | } | ||
1513 | } | ||
1514 | set { | ||
1515 | super.ClearBoundingSphere(); | ||
1516 | float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); | ||
1517 | super.AddBoundingSphere(_PBJtempArray[0]); | ||
1518 | super.AddBoundingSphere(_PBJtempArray[1]); | ||
1519 | super.AddBoundingSphere(_PBJtempArray[2]); | ||
1520 | super.AddBoundingSphere(_PBJtempArray[3]); | ||
1521 | } | ||
1522 | } | ||
1523 | } | ||
1524 | } | ||
1525 | } | ||
1526 | namespace Sirikata.Protocol { | ||
1527 | public class DelObj : PBJ.IMessage { | ||
1528 | protected _PBJ_Internal.DelObj super; | ||
1529 | public _PBJ_Internal.DelObj _PBJSuper{ get { return super;} } | ||
1530 | public DelObj() { | ||
1531 | super=new _PBJ_Internal.DelObj(); | ||
1532 | } | ||
1533 | public DelObj(_PBJ_Internal.DelObj reference) { | ||
1534 | super=reference; | ||
1535 | } | ||
1536 | public static DelObj defaultInstance= new DelObj (_PBJ_Internal.DelObj.DefaultInstance); | ||
1537 | public static DelObj DefaultInstance{ | ||
1538 | get {return defaultInstance;} | ||
1539 | } | ||
1540 | public static pbd.MessageDescriptor Descriptor { | ||
1541 | get { return _PBJ_Internal.DelObj.Descriptor; } } | ||
1542 | public static class Types { | ||
1543 | } | ||
1544 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1545 | return false; | ||
1546 | } | ||
1547 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1548 | return false; | ||
1549 | } | ||
1550 | public const int ObjectReferenceFieldTag=2; | ||
1551 | public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } | ||
1552 | public PBJ.UUID ObjectReference{ get { | ||
1553 | if (HasObjectReference) { | ||
1554 | return PBJ._PBJ.CastUuid(super.ObjectReference); | ||
1555 | } else { | ||
1556 | return PBJ._PBJ.CastUuid(); | ||
1557 | } | ||
1558 | } | ||
1559 | } | ||
1560 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1561 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1562 | public static Builder CreateBuilder() { return new Builder(); } | ||
1563 | public static Builder CreateBuilder(DelObj prototype) { | ||
1564 | return (Builder)new Builder().MergeFrom(prototype); | ||
1565 | } | ||
1566 | public static DelObj ParseFrom(pb::ByteString data) { | ||
1567 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); | ||
1568 | } | ||
1569 | public static DelObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1570 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); | ||
1571 | } | ||
1572 | public static DelObj ParseFrom(byte[] data) { | ||
1573 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); | ||
1574 | } | ||
1575 | public static DelObj ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1576 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); | ||
1577 | } | ||
1578 | public static DelObj ParseFrom(global::System.IO.Stream data) { | ||
1579 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); | ||
1580 | } | ||
1581 | public static DelObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1582 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); | ||
1583 | } | ||
1584 | public static DelObj ParseFrom(pb::CodedInputStream data) { | ||
1585 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data)); | ||
1586 | } | ||
1587 | public static DelObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1588 | return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er)); | ||
1589 | } | ||
1590 | protected override bool _HasAllPBJFields{ get { | ||
1591 | return true | ||
1592 | ; | ||
1593 | } } | ||
1594 | public bool IsInitialized { get { | ||
1595 | return super.IsInitialized&&_HasAllPBJFields; | ||
1596 | } } | ||
1597 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1598 | protected override bool _HasAllPBJFields{ get { | ||
1599 | return true | ||
1600 | ; | ||
1601 | } } | ||
1602 | public bool IsInitialized { get { | ||
1603 | return super.IsInitialized&&_HasAllPBJFields; | ||
1604 | } } | ||
1605 | protected _PBJ_Internal.DelObj.Builder super; | ||
1606 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1607 | public _PBJ_Internal.DelObj.Builder _PBJSuper{ get { return super;} } | ||
1608 | public Builder() {super = new _PBJ_Internal.DelObj.Builder();} | ||
1609 | public Builder(_PBJ_Internal.DelObj.Builder other) { | ||
1610 | super=other; | ||
1611 | } | ||
1612 | public Builder Clone() {return new Builder(super.Clone());} | ||
1613 | public Builder MergeFrom(DelObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1614 | public Builder Clear() {super.Clear();return this;} | ||
1615 | public DelObj BuildPartial() {return new DelObj(super.BuildPartial());} | ||
1616 | public DelObj Build() {if (_HasAllPBJFields) return new DelObj(super.Build());return null;} | ||
1617 | public pbd::MessageDescriptor DescriptorForType { | ||
1618 | get { return DelObj.Descriptor; } } | ||
1619 | public Builder ClearObjectReference() { super.ClearObjectReference();return this;} | ||
1620 | public const int ObjectReferenceFieldTag=2; | ||
1621 | public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} } | ||
1622 | public PBJ.UUID ObjectReference{ get { | ||
1623 | if (HasObjectReference) { | ||
1624 | return PBJ._PBJ.CastUuid(super.ObjectReference); | ||
1625 | } else { | ||
1626 | return PBJ._PBJ.CastUuid(); | ||
1627 | } | ||
1628 | } | ||
1629 | set { | ||
1630 | super.ObjectReference=(PBJ._PBJ.Construct(value)); | ||
1631 | } | ||
1632 | } | ||
1633 | } | ||
1634 | } | ||
1635 | } | ||
1636 | namespace Sirikata.Protocol { | ||
1637 | public class NewProxQuery : PBJ.IMessage { | ||
1638 | protected _PBJ_Internal.NewProxQuery super; | ||
1639 | public _PBJ_Internal.NewProxQuery _PBJSuper{ get { return super;} } | ||
1640 | public NewProxQuery() { | ||
1641 | super=new _PBJ_Internal.NewProxQuery(); | ||
1642 | } | ||
1643 | public NewProxQuery(_PBJ_Internal.NewProxQuery reference) { | ||
1644 | super=reference; | ||
1645 | } | ||
1646 | public static NewProxQuery defaultInstance= new NewProxQuery (_PBJ_Internal.NewProxQuery.DefaultInstance); | ||
1647 | public static NewProxQuery DefaultInstance{ | ||
1648 | get {return defaultInstance;} | ||
1649 | } | ||
1650 | public static pbd.MessageDescriptor Descriptor { | ||
1651 | get { return _PBJ_Internal.NewProxQuery.Descriptor; } } | ||
1652 | public static class Types { | ||
1653 | } | ||
1654 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1655 | return false; | ||
1656 | } | ||
1657 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1658 | return false; | ||
1659 | } | ||
1660 | public const int QueryIdFieldTag=2; | ||
1661 | public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } | ||
1662 | public uint QueryId{ get { | ||
1663 | if (HasQueryId) { | ||
1664 | return PBJ._PBJ.CastUint32(super.QueryId); | ||
1665 | } else { | ||
1666 | return PBJ._PBJ.CastUint32(); | ||
1667 | } | ||
1668 | } | ||
1669 | } | ||
1670 | public const int StatelessFieldTag=3; | ||
1671 | public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} } | ||
1672 | public bool Stateless{ get { | ||
1673 | if (HasStateless) { | ||
1674 | return PBJ._PBJ.CastBool(super.Stateless); | ||
1675 | } else { | ||
1676 | return PBJ._PBJ.CastBool(); | ||
1677 | } | ||
1678 | } | ||
1679 | } | ||
1680 | public const int RelativeCenterFieldTag=4; | ||
1681 | public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} } | ||
1682 | public PBJ.Vector3f RelativeCenter{ get { | ||
1683 | int index=0; | ||
1684 | if (HasRelativeCenter) { | ||
1685 | return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2)); | ||
1686 | } else { | ||
1687 | return PBJ._PBJ.CastVector3f(); | ||
1688 | } | ||
1689 | } | ||
1690 | } | ||
1691 | public const int AbsoluteCenterFieldTag=5; | ||
1692 | public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} } | ||
1693 | public PBJ.Vector3d AbsoluteCenter{ get { | ||
1694 | int index=0; | ||
1695 | if (HasAbsoluteCenter) { | ||
1696 | return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2)); | ||
1697 | } else { | ||
1698 | return PBJ._PBJ.CastVector3d(); | ||
1699 | } | ||
1700 | } | ||
1701 | } | ||
1702 | public const int MaxRadiusFieldTag=6; | ||
1703 | public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} } | ||
1704 | public float MaxRadius{ get { | ||
1705 | if (HasMaxRadius) { | ||
1706 | return PBJ._PBJ.CastFloat(super.MaxRadius); | ||
1707 | } else { | ||
1708 | return PBJ._PBJ.CastFloat(); | ||
1709 | } | ||
1710 | } | ||
1711 | } | ||
1712 | public const int MinSolidAngleFieldTag=7; | ||
1713 | public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} } | ||
1714 | public float MinSolidAngle{ get { | ||
1715 | if (HasMinSolidAngle) { | ||
1716 | return PBJ._PBJ.CastAngle(super.MinSolidAngle); | ||
1717 | } else { | ||
1718 | return PBJ._PBJ.CastAngle(); | ||
1719 | } | ||
1720 | } | ||
1721 | } | ||
1722 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1723 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1724 | public static Builder CreateBuilder() { return new Builder(); } | ||
1725 | public static Builder CreateBuilder(NewProxQuery prototype) { | ||
1726 | return (Builder)new Builder().MergeFrom(prototype); | ||
1727 | } | ||
1728 | public static NewProxQuery ParseFrom(pb::ByteString data) { | ||
1729 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); | ||
1730 | } | ||
1731 | public static NewProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1732 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); | ||
1733 | } | ||
1734 | public static NewProxQuery ParseFrom(byte[] data) { | ||
1735 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); | ||
1736 | } | ||
1737 | public static NewProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1738 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); | ||
1739 | } | ||
1740 | public static NewProxQuery ParseFrom(global::System.IO.Stream data) { | ||
1741 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); | ||
1742 | } | ||
1743 | public static NewProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1744 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); | ||
1745 | } | ||
1746 | public static NewProxQuery ParseFrom(pb::CodedInputStream data) { | ||
1747 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data)); | ||
1748 | } | ||
1749 | public static NewProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1750 | return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er)); | ||
1751 | } | ||
1752 | protected override bool _HasAllPBJFields{ get { | ||
1753 | return true | ||
1754 | ; | ||
1755 | } } | ||
1756 | public bool IsInitialized { get { | ||
1757 | return super.IsInitialized&&_HasAllPBJFields; | ||
1758 | } } | ||
1759 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1760 | protected override bool _HasAllPBJFields{ get { | ||
1761 | return true | ||
1762 | ; | ||
1763 | } } | ||
1764 | public bool IsInitialized { get { | ||
1765 | return super.IsInitialized&&_HasAllPBJFields; | ||
1766 | } } | ||
1767 | protected _PBJ_Internal.NewProxQuery.Builder super; | ||
1768 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1769 | public _PBJ_Internal.NewProxQuery.Builder _PBJSuper{ get { return super;} } | ||
1770 | public Builder() {super = new _PBJ_Internal.NewProxQuery.Builder();} | ||
1771 | public Builder(_PBJ_Internal.NewProxQuery.Builder other) { | ||
1772 | super=other; | ||
1773 | } | ||
1774 | public Builder Clone() {return new Builder(super.Clone());} | ||
1775 | public Builder MergeFrom(NewProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1776 | public Builder Clear() {super.Clear();return this;} | ||
1777 | public NewProxQuery BuildPartial() {return new NewProxQuery(super.BuildPartial());} | ||
1778 | public NewProxQuery Build() {if (_HasAllPBJFields) return new NewProxQuery(super.Build());return null;} | ||
1779 | public pbd::MessageDescriptor DescriptorForType { | ||
1780 | get { return NewProxQuery.Descriptor; } } | ||
1781 | public Builder ClearQueryId() { super.ClearQueryId();return this;} | ||
1782 | public const int QueryIdFieldTag=2; | ||
1783 | public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } | ||
1784 | public uint QueryId{ get { | ||
1785 | if (HasQueryId) { | ||
1786 | return PBJ._PBJ.CastUint32(super.QueryId); | ||
1787 | } else { | ||
1788 | return PBJ._PBJ.CastUint32(); | ||
1789 | } | ||
1790 | } | ||
1791 | set { | ||
1792 | super.QueryId=(PBJ._PBJ.Construct(value)); | ||
1793 | } | ||
1794 | } | ||
1795 | public Builder ClearStateless() { super.ClearStateless();return this;} | ||
1796 | public const int StatelessFieldTag=3; | ||
1797 | public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} } | ||
1798 | public bool Stateless{ get { | ||
1799 | if (HasStateless) { | ||
1800 | return PBJ._PBJ.CastBool(super.Stateless); | ||
1801 | } else { | ||
1802 | return PBJ._PBJ.CastBool(); | ||
1803 | } | ||
1804 | } | ||
1805 | set { | ||
1806 | super.Stateless=(PBJ._PBJ.Construct(value)); | ||
1807 | } | ||
1808 | } | ||
1809 | public Builder ClearRelativeCenter() { super.ClearRelativeCenter();return this;} | ||
1810 | public const int RelativeCenterFieldTag=4; | ||
1811 | public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} } | ||
1812 | public PBJ.Vector3f RelativeCenter{ get { | ||
1813 | int index=0; | ||
1814 | if (HasRelativeCenter) { | ||
1815 | return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2)); | ||
1816 | } else { | ||
1817 | return PBJ._PBJ.CastVector3f(); | ||
1818 | } | ||
1819 | } | ||
1820 | set { | ||
1821 | super.ClearRelativeCenter(); | ||
1822 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
1823 | super.AddRelativeCenter(_PBJtempArray[0]); | ||
1824 | super.AddRelativeCenter(_PBJtempArray[1]); | ||
1825 | super.AddRelativeCenter(_PBJtempArray[2]); | ||
1826 | } | ||
1827 | } | ||
1828 | public Builder ClearAbsoluteCenter() { super.ClearAbsoluteCenter();return this;} | ||
1829 | public const int AbsoluteCenterFieldTag=5; | ||
1830 | public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} } | ||
1831 | public PBJ.Vector3d AbsoluteCenter{ get { | ||
1832 | int index=0; | ||
1833 | if (HasAbsoluteCenter) { | ||
1834 | return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2)); | ||
1835 | } else { | ||
1836 | return PBJ._PBJ.CastVector3d(); | ||
1837 | } | ||
1838 | } | ||
1839 | set { | ||
1840 | super.ClearAbsoluteCenter(); | ||
1841 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
1842 | super.AddAbsoluteCenter(_PBJtempArray[0]); | ||
1843 | super.AddAbsoluteCenter(_PBJtempArray[1]); | ||
1844 | super.AddAbsoluteCenter(_PBJtempArray[2]); | ||
1845 | } | ||
1846 | } | ||
1847 | public Builder ClearMaxRadius() { super.ClearMaxRadius();return this;} | ||
1848 | public const int MaxRadiusFieldTag=6; | ||
1849 | public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} } | ||
1850 | public float MaxRadius{ get { | ||
1851 | if (HasMaxRadius) { | ||
1852 | return PBJ._PBJ.CastFloat(super.MaxRadius); | ||
1853 | } else { | ||
1854 | return PBJ._PBJ.CastFloat(); | ||
1855 | } | ||
1856 | } | ||
1857 | set { | ||
1858 | super.MaxRadius=(PBJ._PBJ.Construct(value)); | ||
1859 | } | ||
1860 | } | ||
1861 | public Builder ClearMinSolidAngle() { super.ClearMinSolidAngle();return this;} | ||
1862 | public const int MinSolidAngleFieldTag=7; | ||
1863 | public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} } | ||
1864 | public float MinSolidAngle{ get { | ||
1865 | if (HasMinSolidAngle) { | ||
1866 | return PBJ._PBJ.CastAngle(super.MinSolidAngle); | ||
1867 | } else { | ||
1868 | return PBJ._PBJ.CastAngle(); | ||
1869 | } | ||
1870 | } | ||
1871 | set { | ||
1872 | super.MinSolidAngle=(PBJ._PBJ.Construct(value)); | ||
1873 | } | ||
1874 | } | ||
1875 | } | ||
1876 | } | ||
1877 | } | ||
1878 | namespace Sirikata.Protocol { | ||
1879 | public class ProxCall : PBJ.IMessage { | ||
1880 | protected _PBJ_Internal.ProxCall super; | ||
1881 | public _PBJ_Internal.ProxCall _PBJSuper{ get { return super;} } | ||
1882 | public ProxCall() { | ||
1883 | super=new _PBJ_Internal.ProxCall(); | ||
1884 | } | ||
1885 | public ProxCall(_PBJ_Internal.ProxCall reference) { | ||
1886 | super=reference; | ||
1887 | } | ||
1888 | public static ProxCall defaultInstance= new ProxCall (_PBJ_Internal.ProxCall.DefaultInstance); | ||
1889 | public static ProxCall DefaultInstance{ | ||
1890 | get {return defaultInstance;} | ||
1891 | } | ||
1892 | public static pbd.MessageDescriptor Descriptor { | ||
1893 | get { return _PBJ_Internal.ProxCall.Descriptor; } } | ||
1894 | public static class Types { | ||
1895 | public enum ProximityEvent { | ||
1896 | EXITED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY, | ||
1897 | ENTERED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.ENTERED_PROXIMITY, | ||
1898 | STATELESS_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.STATELESS_PROXIMITY | ||
1899 | }; | ||
1900 | } | ||
1901 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
1902 | return false; | ||
1903 | } | ||
1904 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
1905 | return false; | ||
1906 | } | ||
1907 | public const int QueryIdFieldTag=2; | ||
1908 | public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } | ||
1909 | public uint QueryId{ get { | ||
1910 | if (HasQueryId) { | ||
1911 | return PBJ._PBJ.CastUint32(super.QueryId); | ||
1912 | } else { | ||
1913 | return PBJ._PBJ.CastUint32(); | ||
1914 | } | ||
1915 | } | ||
1916 | } | ||
1917 | public const int ProximateObjectFieldTag=3; | ||
1918 | public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} } | ||
1919 | public PBJ.UUID ProximateObject{ get { | ||
1920 | if (HasProximateObject) { | ||
1921 | return PBJ._PBJ.CastUuid(super.ProximateObject); | ||
1922 | } else { | ||
1923 | return PBJ._PBJ.CastUuid(); | ||
1924 | } | ||
1925 | } | ||
1926 | } | ||
1927 | public const int ProximityEventFieldTag=4; | ||
1928 | public bool HasProximityEvent{ get {return super.HasProximityEvent;} } | ||
1929 | public Types.ProximityEvent ProximityEvent{ get { | ||
1930 | if (HasProximityEvent) { | ||
1931 | return (Types.ProximityEvent)super.ProximityEvent; | ||
1932 | } else { | ||
1933 | return new Types.ProximityEvent(); | ||
1934 | } | ||
1935 | } | ||
1936 | } | ||
1937 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1938 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1939 | public static Builder CreateBuilder() { return new Builder(); } | ||
1940 | public static Builder CreateBuilder(ProxCall prototype) { | ||
1941 | return (Builder)new Builder().MergeFrom(prototype); | ||
1942 | } | ||
1943 | public static ProxCall ParseFrom(pb::ByteString data) { | ||
1944 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); | ||
1945 | } | ||
1946 | public static ProxCall ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1947 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); | ||
1948 | } | ||
1949 | public static ProxCall ParseFrom(byte[] data) { | ||
1950 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); | ||
1951 | } | ||
1952 | public static ProxCall ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1953 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); | ||
1954 | } | ||
1955 | public static ProxCall ParseFrom(global::System.IO.Stream data) { | ||
1956 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); | ||
1957 | } | ||
1958 | public static ProxCall ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1959 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); | ||
1960 | } | ||
1961 | public static ProxCall ParseFrom(pb::CodedInputStream data) { | ||
1962 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data)); | ||
1963 | } | ||
1964 | public static ProxCall ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1965 | return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er)); | ||
1966 | } | ||
1967 | protected override bool _HasAllPBJFields{ get { | ||
1968 | return true | ||
1969 | ; | ||
1970 | } } | ||
1971 | public bool IsInitialized { get { | ||
1972 | return super.IsInitialized&&_HasAllPBJFields; | ||
1973 | } } | ||
1974 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1975 | protected override bool _HasAllPBJFields{ get { | ||
1976 | return true | ||
1977 | ; | ||
1978 | } } | ||
1979 | public bool IsInitialized { get { | ||
1980 | return super.IsInitialized&&_HasAllPBJFields; | ||
1981 | } } | ||
1982 | protected _PBJ_Internal.ProxCall.Builder super; | ||
1983 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1984 | public _PBJ_Internal.ProxCall.Builder _PBJSuper{ get { return super;} } | ||
1985 | public Builder() {super = new _PBJ_Internal.ProxCall.Builder();} | ||
1986 | public Builder(_PBJ_Internal.ProxCall.Builder other) { | ||
1987 | super=other; | ||
1988 | } | ||
1989 | public Builder Clone() {return new Builder(super.Clone());} | ||
1990 | public Builder MergeFrom(ProxCall prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1991 | public Builder Clear() {super.Clear();return this;} | ||
1992 | public ProxCall BuildPartial() {return new ProxCall(super.BuildPartial());} | ||
1993 | public ProxCall Build() {if (_HasAllPBJFields) return new ProxCall(super.Build());return null;} | ||
1994 | public pbd::MessageDescriptor DescriptorForType { | ||
1995 | get { return ProxCall.Descriptor; } } | ||
1996 | public Builder ClearQueryId() { super.ClearQueryId();return this;} | ||
1997 | public const int QueryIdFieldTag=2; | ||
1998 | public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } | ||
1999 | public uint QueryId{ get { | ||
2000 | if (HasQueryId) { | ||
2001 | return PBJ._PBJ.CastUint32(super.QueryId); | ||
2002 | } else { | ||
2003 | return PBJ._PBJ.CastUint32(); | ||
2004 | } | ||
2005 | } | ||
2006 | set { | ||
2007 | super.QueryId=(PBJ._PBJ.Construct(value)); | ||
2008 | } | ||
2009 | } | ||
2010 | public Builder ClearProximateObject() { super.ClearProximateObject();return this;} | ||
2011 | public const int ProximateObjectFieldTag=3; | ||
2012 | public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} } | ||
2013 | public PBJ.UUID ProximateObject{ get { | ||
2014 | if (HasProximateObject) { | ||
2015 | return PBJ._PBJ.CastUuid(super.ProximateObject); | ||
2016 | } else { | ||
2017 | return PBJ._PBJ.CastUuid(); | ||
2018 | } | ||
2019 | } | ||
2020 | set { | ||
2021 | super.ProximateObject=(PBJ._PBJ.Construct(value)); | ||
2022 | } | ||
2023 | } | ||
2024 | public Builder ClearProximityEvent() { super.ClearProximityEvent();return this;} | ||
2025 | public const int ProximityEventFieldTag=4; | ||
2026 | public bool HasProximityEvent{ get {return super.HasProximityEvent;} } | ||
2027 | public Types.ProximityEvent ProximityEvent{ get { | ||
2028 | if (HasProximityEvent) { | ||
2029 | return (Types.ProximityEvent)super.ProximityEvent; | ||
2030 | } else { | ||
2031 | return new Types.ProximityEvent(); | ||
2032 | } | ||
2033 | } | ||
2034 | set { | ||
2035 | super.ProximityEvent=((_PBJ_Internal.ProxCall.Types.ProximityEvent)value); | ||
2036 | } | ||
2037 | } | ||
2038 | } | ||
2039 | } | ||
2040 | } | ||
2041 | namespace Sirikata.Protocol { | ||
2042 | public class DelProxQuery : PBJ.IMessage { | ||
2043 | protected _PBJ_Internal.DelProxQuery super; | ||
2044 | public _PBJ_Internal.DelProxQuery _PBJSuper{ get { return super;} } | ||
2045 | public DelProxQuery() { | ||
2046 | super=new _PBJ_Internal.DelProxQuery(); | ||
2047 | } | ||
2048 | public DelProxQuery(_PBJ_Internal.DelProxQuery reference) { | ||
2049 | super=reference; | ||
2050 | } | ||
2051 | public static DelProxQuery defaultInstance= new DelProxQuery (_PBJ_Internal.DelProxQuery.DefaultInstance); | ||
2052 | public static DelProxQuery DefaultInstance{ | ||
2053 | get {return defaultInstance;} | ||
2054 | } | ||
2055 | public static pbd.MessageDescriptor Descriptor { | ||
2056 | get { return _PBJ_Internal.DelProxQuery.Descriptor; } } | ||
2057 | public static class Types { | ||
2058 | } | ||
2059 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
2060 | return false; | ||
2061 | } | ||
2062 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
2063 | return false; | ||
2064 | } | ||
2065 | public const int QueryIdFieldTag=2; | ||
2066 | public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } | ||
2067 | public uint QueryId{ get { | ||
2068 | if (HasQueryId) { | ||
2069 | return PBJ._PBJ.CastUint32(super.QueryId); | ||
2070 | } else { | ||
2071 | return PBJ._PBJ.CastUint32(); | ||
2072 | } | ||
2073 | } | ||
2074 | } | ||
2075 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
2076 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
2077 | public static Builder CreateBuilder() { return new Builder(); } | ||
2078 | public static Builder CreateBuilder(DelProxQuery prototype) { | ||
2079 | return (Builder)new Builder().MergeFrom(prototype); | ||
2080 | } | ||
2081 | public static DelProxQuery ParseFrom(pb::ByteString data) { | ||
2082 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); | ||
2083 | } | ||
2084 | public static DelProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
2085 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); | ||
2086 | } | ||
2087 | public static DelProxQuery ParseFrom(byte[] data) { | ||
2088 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); | ||
2089 | } | ||
2090 | public static DelProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
2091 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); | ||
2092 | } | ||
2093 | public static DelProxQuery ParseFrom(global::System.IO.Stream data) { | ||
2094 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); | ||
2095 | } | ||
2096 | public static DelProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
2097 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); | ||
2098 | } | ||
2099 | public static DelProxQuery ParseFrom(pb::CodedInputStream data) { | ||
2100 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data)); | ||
2101 | } | ||
2102 | public static DelProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
2103 | return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er)); | ||
2104 | } | ||
2105 | protected override bool _HasAllPBJFields{ get { | ||
2106 | return true | ||
2107 | ; | ||
2108 | } } | ||
2109 | public bool IsInitialized { get { | ||
2110 | return super.IsInitialized&&_HasAllPBJFields; | ||
2111 | } } | ||
2112 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
2113 | protected override bool _HasAllPBJFields{ get { | ||
2114 | return true | ||
2115 | ; | ||
2116 | } } | ||
2117 | public bool IsInitialized { get { | ||
2118 | return super.IsInitialized&&_HasAllPBJFields; | ||
2119 | } } | ||
2120 | protected _PBJ_Internal.DelProxQuery.Builder super; | ||
2121 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
2122 | public _PBJ_Internal.DelProxQuery.Builder _PBJSuper{ get { return super;} } | ||
2123 | public Builder() {super = new _PBJ_Internal.DelProxQuery.Builder();} | ||
2124 | public Builder(_PBJ_Internal.DelProxQuery.Builder other) { | ||
2125 | super=other; | ||
2126 | } | ||
2127 | public Builder Clone() {return new Builder(super.Clone());} | ||
2128 | public Builder MergeFrom(DelProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
2129 | public Builder Clear() {super.Clear();return this;} | ||
2130 | public DelProxQuery BuildPartial() {return new DelProxQuery(super.BuildPartial());} | ||
2131 | public DelProxQuery Build() {if (_HasAllPBJFields) return new DelProxQuery(super.Build());return null;} | ||
2132 | public pbd::MessageDescriptor DescriptorForType { | ||
2133 | get { return DelProxQuery.Descriptor; } } | ||
2134 | public Builder ClearQueryId() { super.ClearQueryId();return this;} | ||
2135 | public const int QueryIdFieldTag=2; | ||
2136 | public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} } | ||
2137 | public uint QueryId{ get { | ||
2138 | if (HasQueryId) { | ||
2139 | return PBJ._PBJ.CastUint32(super.QueryId); | ||
2140 | } else { | ||
2141 | return PBJ._PBJ.CastUint32(); | ||
2142 | } | ||
2143 | } | ||
2144 | set { | ||
2145 | super.QueryId=(PBJ._PBJ.Construct(value)); | ||
2146 | } | ||
2147 | } | ||
2148 | } | ||
2149 | } | ||
2150 | } | ||
2151 | namespace Sirikata.Protocol { | ||
2152 | public class Vector3fProperty : PBJ.IMessage { | ||
2153 | protected _PBJ_Internal.Vector3fProperty super; | ||
2154 | public _PBJ_Internal.Vector3fProperty _PBJSuper{ get { return super;} } | ||
2155 | public Vector3fProperty() { | ||
2156 | super=new _PBJ_Internal.Vector3fProperty(); | ||
2157 | } | ||
2158 | public Vector3fProperty(_PBJ_Internal.Vector3fProperty reference) { | ||
2159 | super=reference; | ||
2160 | } | ||
2161 | public static Vector3fProperty defaultInstance= new Vector3fProperty (_PBJ_Internal.Vector3fProperty.DefaultInstance); | ||
2162 | public static Vector3fProperty DefaultInstance{ | ||
2163 | get {return defaultInstance;} | ||
2164 | } | ||
2165 | public static pbd.MessageDescriptor Descriptor { | ||
2166 | get { return _PBJ_Internal.Vector3fProperty.Descriptor; } } | ||
2167 | public static class Types { | ||
2168 | } | ||
2169 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
2170 | return false; | ||
2171 | } | ||
2172 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
2173 | return false; | ||
2174 | } | ||
2175 | public const int ValueFieldTag=10; | ||
2176 | public bool HasValue{ get {return super.ValueCount>=3;} } | ||
2177 | public PBJ.Vector3f Value{ get { | ||
2178 | int index=0; | ||
2179 | if (HasValue) { | ||
2180 | return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2)); | ||
2181 | } else { | ||
2182 | return PBJ._PBJ.CastVector3f(); | ||
2183 | } | ||
2184 | } | ||
2185 | } | ||
2186 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
2187 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
2188 | public static Builder CreateBuilder() { return new Builder(); } | ||
2189 | public static Builder CreateBuilder(Vector3fProperty prototype) { | ||
2190 | return (Builder)new Builder().MergeFrom(prototype); | ||
2191 | } | ||
2192 | public static Vector3fProperty ParseFrom(pb::ByteString data) { | ||
2193 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); | ||
2194 | } | ||
2195 | public static Vector3fProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
2196 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); | ||
2197 | } | ||
2198 | public static Vector3fProperty ParseFrom(byte[] data) { | ||
2199 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); | ||
2200 | } | ||
2201 | public static Vector3fProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
2202 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); | ||
2203 | } | ||
2204 | public static Vector3fProperty ParseFrom(global::System.IO.Stream data) { | ||
2205 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); | ||
2206 | } | ||
2207 | public static Vector3fProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
2208 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); | ||
2209 | } | ||
2210 | public static Vector3fProperty ParseFrom(pb::CodedInputStream data) { | ||
2211 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data)); | ||
2212 | } | ||
2213 | public static Vector3fProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
2214 | return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er)); | ||
2215 | } | ||
2216 | protected override bool _HasAllPBJFields{ get { | ||
2217 | return true | ||
2218 | ; | ||
2219 | } } | ||
2220 | public bool IsInitialized { get { | ||
2221 | return super.IsInitialized&&_HasAllPBJFields; | ||
2222 | } } | ||
2223 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
2224 | protected override bool _HasAllPBJFields{ get { | ||
2225 | return true | ||
2226 | ; | ||
2227 | } } | ||
2228 | public bool IsInitialized { get { | ||
2229 | return super.IsInitialized&&_HasAllPBJFields; | ||
2230 | } } | ||
2231 | protected _PBJ_Internal.Vector3fProperty.Builder super; | ||
2232 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
2233 | public _PBJ_Internal.Vector3fProperty.Builder _PBJSuper{ get { return super;} } | ||
2234 | public Builder() {super = new _PBJ_Internal.Vector3fProperty.Builder();} | ||
2235 | public Builder(_PBJ_Internal.Vector3fProperty.Builder other) { | ||
2236 | super=other; | ||
2237 | } | ||
2238 | public Builder Clone() {return new Builder(super.Clone());} | ||
2239 | public Builder MergeFrom(Vector3fProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
2240 | public Builder Clear() {super.Clear();return this;} | ||
2241 | public Vector3fProperty BuildPartial() {return new Vector3fProperty(super.BuildPartial());} | ||
2242 | public Vector3fProperty Build() {if (_HasAllPBJFields) return new Vector3fProperty(super.Build());return null;} | ||
2243 | public pbd::MessageDescriptor DescriptorForType { | ||
2244 | get { return Vector3fProperty.Descriptor; } } | ||
2245 | public Builder ClearValue() { super.ClearValue();return this;} | ||
2246 | public const int ValueFieldTag=10; | ||
2247 | public bool HasValue{ get {return super.ValueCount>=3;} } | ||
2248 | public PBJ.Vector3f Value{ get { | ||
2249 | int index=0; | ||
2250 | if (HasValue) { | ||
2251 | return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2)); | ||
2252 | } else { | ||
2253 | return PBJ._PBJ.CastVector3f(); | ||
2254 | } | ||
2255 | } | ||
2256 | set { | ||
2257 | super.ClearValue(); | ||
2258 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
2259 | super.AddValue(_PBJtempArray[0]); | ||
2260 | super.AddValue(_PBJtempArray[1]); | ||
2261 | super.AddValue(_PBJtempArray[2]); | ||
2262 | } | ||
2263 | } | ||
2264 | } | ||
2265 | } | ||
2266 | } | ||
2267 | namespace Sirikata.Protocol { | ||
2268 | public class StringProperty : PBJ.IMessage { | ||
2269 | protected _PBJ_Internal.StringProperty super; | ||
2270 | public _PBJ_Internal.StringProperty _PBJSuper{ get { return super;} } | ||
2271 | public StringProperty() { | ||
2272 | super=new _PBJ_Internal.StringProperty(); | ||
2273 | } | ||
2274 | public StringProperty(_PBJ_Internal.StringProperty reference) { | ||
2275 | super=reference; | ||
2276 | } | ||
2277 | public static StringProperty defaultInstance= new StringProperty (_PBJ_Internal.StringProperty.DefaultInstance); | ||
2278 | public static StringProperty DefaultInstance{ | ||
2279 | get {return defaultInstance;} | ||
2280 | } | ||
2281 | public static pbd.MessageDescriptor Descriptor { | ||
2282 | get { return _PBJ_Internal.StringProperty.Descriptor; } } | ||
2283 | public static class Types { | ||
2284 | } | ||
2285 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
2286 | return false; | ||
2287 | } | ||
2288 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
2289 | return false; | ||
2290 | } | ||
2291 | public const int ValueFieldTag=10; | ||
2292 | public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} } | ||
2293 | public string Value{ get { | ||
2294 | if (HasValue) { | ||
2295 | return PBJ._PBJ.CastString(super.Value); | ||
2296 | } else { | ||
2297 | return PBJ._PBJ.CastString(); | ||
2298 | } | ||
2299 | } | ||
2300 | } | ||
2301 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
2302 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
2303 | public static Builder CreateBuilder() { return new Builder(); } | ||
2304 | public static Builder CreateBuilder(StringProperty prototype) { | ||
2305 | return (Builder)new Builder().MergeFrom(prototype); | ||
2306 | } | ||
2307 | public static StringProperty ParseFrom(pb::ByteString data) { | ||
2308 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); | ||
2309 | } | ||
2310 | public static StringProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
2311 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); | ||
2312 | } | ||
2313 | public static StringProperty ParseFrom(byte[] data) { | ||
2314 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); | ||
2315 | } | ||
2316 | public static StringProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
2317 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); | ||
2318 | } | ||
2319 | public static StringProperty ParseFrom(global::System.IO.Stream data) { | ||
2320 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); | ||
2321 | } | ||
2322 | public static StringProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
2323 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); | ||
2324 | } | ||
2325 | public static StringProperty ParseFrom(pb::CodedInputStream data) { | ||
2326 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data)); | ||
2327 | } | ||
2328 | public static StringProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
2329 | return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er)); | ||
2330 | } | ||
2331 | protected override bool _HasAllPBJFields{ get { | ||
2332 | return true | ||
2333 | ; | ||
2334 | } } | ||
2335 | public bool IsInitialized { get { | ||
2336 | return super.IsInitialized&&_HasAllPBJFields; | ||
2337 | } } | ||
2338 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
2339 | protected override bool _HasAllPBJFields{ get { | ||
2340 | return true | ||
2341 | ; | ||
2342 | } } | ||
2343 | public bool IsInitialized { get { | ||
2344 | return super.IsInitialized&&_HasAllPBJFields; | ||
2345 | } } | ||
2346 | protected _PBJ_Internal.StringProperty.Builder super; | ||
2347 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
2348 | public _PBJ_Internal.StringProperty.Builder _PBJSuper{ get { return super;} } | ||
2349 | public Builder() {super = new _PBJ_Internal.StringProperty.Builder();} | ||
2350 | public Builder(_PBJ_Internal.StringProperty.Builder other) { | ||
2351 | super=other; | ||
2352 | } | ||
2353 | public Builder Clone() {return new Builder(super.Clone());} | ||
2354 | public Builder MergeFrom(StringProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
2355 | public Builder Clear() {super.Clear();return this;} | ||
2356 | public StringProperty BuildPartial() {return new StringProperty(super.BuildPartial());} | ||
2357 | public StringProperty Build() {if (_HasAllPBJFields) return new StringProperty(super.Build());return null;} | ||
2358 | public pbd::MessageDescriptor DescriptorForType { | ||
2359 | get { return StringProperty.Descriptor; } } | ||
2360 | public Builder ClearValue() { super.ClearValue();return this;} | ||
2361 | public const int ValueFieldTag=10; | ||
2362 | public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} } | ||
2363 | public string Value{ get { | ||
2364 | if (HasValue) { | ||
2365 | return PBJ._PBJ.CastString(super.Value); | ||
2366 | } else { | ||
2367 | return PBJ._PBJ.CastString(); | ||
2368 | } | ||
2369 | } | ||
2370 | set { | ||
2371 | super.Value=(PBJ._PBJ.Construct(value)); | ||
2372 | } | ||
2373 | } | ||
2374 | } | ||
2375 | } | ||
2376 | } | ||
2377 | namespace Sirikata.Protocol { | ||
2378 | public class StringMapProperty : PBJ.IMessage { | ||
2379 | protected _PBJ_Internal.StringMapProperty super; | ||
2380 | public _PBJ_Internal.StringMapProperty _PBJSuper{ get { return super;} } | ||
2381 | public StringMapProperty() { | ||
2382 | super=new _PBJ_Internal.StringMapProperty(); | ||
2383 | } | ||
2384 | public StringMapProperty(_PBJ_Internal.StringMapProperty reference) { | ||
2385 | super=reference; | ||
2386 | } | ||
2387 | public static StringMapProperty defaultInstance= new StringMapProperty (_PBJ_Internal.StringMapProperty.DefaultInstance); | ||
2388 | public static StringMapProperty DefaultInstance{ | ||
2389 | get {return defaultInstance;} | ||
2390 | } | ||
2391 | public static pbd.MessageDescriptor Descriptor { | ||
2392 | get { return _PBJ_Internal.StringMapProperty.Descriptor; } } | ||
2393 | public static class Types { | ||
2394 | } | ||
2395 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
2396 | return false; | ||
2397 | } | ||
2398 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
2399 | return false; | ||
2400 | } | ||
2401 | public const int KeysFieldTag=2; | ||
2402 | public int KeysCount { get { return super.KeysCount;} } | ||
2403 | public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));} | ||
2404 | public string Keys(int index) { | ||
2405 | return (string)PBJ._PBJ.CastString(super.GetKeys(index)); | ||
2406 | } | ||
2407 | public const int ValuesFieldTag=3; | ||
2408 | public int ValuesCount { get { return super.ValuesCount;} } | ||
2409 | public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));} | ||
2410 | public string Values(int index) { | ||
2411 | return (string)PBJ._PBJ.CastString(super.GetValues(index)); | ||
2412 | } | ||
2413 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
2414 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
2415 | public static Builder CreateBuilder() { return new Builder(); } | ||
2416 | public static Builder CreateBuilder(StringMapProperty prototype) { | ||
2417 | return (Builder)new Builder().MergeFrom(prototype); | ||
2418 | } | ||
2419 | public static StringMapProperty ParseFrom(pb::ByteString data) { | ||
2420 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); | ||
2421 | } | ||
2422 | public static StringMapProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
2423 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); | ||
2424 | } | ||
2425 | public static StringMapProperty ParseFrom(byte[] data) { | ||
2426 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); | ||
2427 | } | ||
2428 | public static StringMapProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
2429 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); | ||
2430 | } | ||
2431 | public static StringMapProperty ParseFrom(global::System.IO.Stream data) { | ||
2432 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); | ||
2433 | } | ||
2434 | public static StringMapProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
2435 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); | ||
2436 | } | ||
2437 | public static StringMapProperty ParseFrom(pb::CodedInputStream data) { | ||
2438 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data)); | ||
2439 | } | ||
2440 | public static StringMapProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
2441 | return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er)); | ||
2442 | } | ||
2443 | protected override bool _HasAllPBJFields{ get { | ||
2444 | return true | ||
2445 | ; | ||
2446 | } } | ||
2447 | public bool IsInitialized { get { | ||
2448 | return super.IsInitialized&&_HasAllPBJFields; | ||
2449 | } } | ||
2450 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
2451 | protected override bool _HasAllPBJFields{ get { | ||
2452 | return true | ||
2453 | ; | ||
2454 | } } | ||
2455 | public bool IsInitialized { get { | ||
2456 | return super.IsInitialized&&_HasAllPBJFields; | ||
2457 | } } | ||
2458 | protected _PBJ_Internal.StringMapProperty.Builder super; | ||
2459 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
2460 | public _PBJ_Internal.StringMapProperty.Builder _PBJSuper{ get { return super;} } | ||
2461 | public Builder() {super = new _PBJ_Internal.StringMapProperty.Builder();} | ||
2462 | public Builder(_PBJ_Internal.StringMapProperty.Builder other) { | ||
2463 | super=other; | ||
2464 | } | ||
2465 | public Builder Clone() {return new Builder(super.Clone());} | ||
2466 | public Builder MergeFrom(StringMapProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
2467 | public Builder Clear() {super.Clear();return this;} | ||
2468 | public StringMapProperty BuildPartial() {return new StringMapProperty(super.BuildPartial());} | ||
2469 | public StringMapProperty Build() {if (_HasAllPBJFields) return new StringMapProperty(super.Build());return null;} | ||
2470 | public pbd::MessageDescriptor DescriptorForType { | ||
2471 | get { return StringMapProperty.Descriptor; } } | ||
2472 | public Builder ClearKeys() { super.ClearKeys();return this;} | ||
2473 | public Builder SetKeys(int index, string value) { | ||
2474 | super.SetKeys(index,PBJ._PBJ.Construct(value)); | ||
2475 | return this; | ||
2476 | } | ||
2477 | public const int KeysFieldTag=2; | ||
2478 | public int KeysCount { get { return super.KeysCount;} } | ||
2479 | public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));} | ||
2480 | public string Keys(int index) { | ||
2481 | return (string)PBJ._PBJ.CastString(super.GetKeys(index)); | ||
2482 | } | ||
2483 | public Builder AddKeys(string value) { | ||
2484 | super.AddKeys(PBJ._PBJ.Construct(value)); | ||
2485 | return this; | ||
2486 | } | ||
2487 | public Builder ClearValues() { super.ClearValues();return this;} | ||
2488 | public Builder SetValues(int index, string value) { | ||
2489 | super.SetValues(index,PBJ._PBJ.Construct(value)); | ||
2490 | return this; | ||
2491 | } | ||
2492 | public const int ValuesFieldTag=3; | ||
2493 | public int ValuesCount { get { return super.ValuesCount;} } | ||
2494 | public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));} | ||
2495 | public string Values(int index) { | ||
2496 | return (string)PBJ._PBJ.CastString(super.GetValues(index)); | ||
2497 | } | ||
2498 | public Builder AddValues(string value) { | ||
2499 | super.AddValues(PBJ._PBJ.Construct(value)); | ||
2500 | return this; | ||
2501 | } | ||
2502 | } | ||
2503 | } | ||
2504 | } | ||
2505 | namespace Sirikata.Protocol { | ||
2506 | public class PhysicalParameters : PBJ.IMessage { | ||
2507 | protected _PBJ_Internal.PhysicalParameters super; | ||
2508 | public _PBJ_Internal.PhysicalParameters _PBJSuper{ get { return super;} } | ||
2509 | public PhysicalParameters() { | ||
2510 | super=new _PBJ_Internal.PhysicalParameters(); | ||
2511 | } | ||
2512 | public PhysicalParameters(_PBJ_Internal.PhysicalParameters reference) { | ||
2513 | super=reference; | ||
2514 | } | ||
2515 | public static PhysicalParameters defaultInstance= new PhysicalParameters (_PBJ_Internal.PhysicalParameters.DefaultInstance); | ||
2516 | public static PhysicalParameters DefaultInstance{ | ||
2517 | get {return defaultInstance;} | ||
2518 | } | ||
2519 | public static pbd.MessageDescriptor Descriptor { | ||
2520 | get { return _PBJ_Internal.PhysicalParameters.Descriptor; } } | ||
2521 | public static class Types { | ||
2522 | public enum Mode { | ||
2523 | NONPHYSICAL=_PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL, | ||
2524 | STATIC=_PBJ_Internal.PhysicalParameters.Types.Mode.STATIC, | ||
2525 | DYNAMICBOX=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICBOX, | ||
2526 | DYNAMICSPHERE=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICSPHERE, | ||
2527 | DYNAMICCYLINDER=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICCYLINDER, | ||
2528 | CHARACTER=_PBJ_Internal.PhysicalParameters.Types.Mode.CHARACTER | ||
2529 | }; | ||
2530 | } | ||
2531 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
2532 | return false; | ||
2533 | } | ||
2534 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
2535 | return false; | ||
2536 | } | ||
2537 | public const int ModeFieldTag=2; | ||
2538 | public bool HasMode{ get {return super.HasMode;} } | ||
2539 | public Types.Mode Mode{ get { | ||
2540 | if (HasMode) { | ||
2541 | return (Types.Mode)super.Mode; | ||
2542 | } else { | ||
2543 | return new Types.Mode(); | ||
2544 | } | ||
2545 | } | ||
2546 | } | ||
2547 | public const int DensityFieldTag=3; | ||
2548 | public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} } | ||
2549 | public float Density{ get { | ||
2550 | if (HasDensity) { | ||
2551 | return PBJ._PBJ.CastFloat(super.Density); | ||
2552 | } else { | ||
2553 | return PBJ._PBJ.CastFloat(); | ||
2554 | } | ||
2555 | } | ||
2556 | } | ||
2557 | public const int FrictionFieldTag=4; | ||
2558 | public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} } | ||
2559 | public float Friction{ get { | ||
2560 | if (HasFriction) { | ||
2561 | return PBJ._PBJ.CastFloat(super.Friction); | ||
2562 | } else { | ||
2563 | return PBJ._PBJ.CastFloat(); | ||
2564 | } | ||
2565 | } | ||
2566 | } | ||
2567 | public const int BounceFieldTag=5; | ||
2568 | public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} } | ||
2569 | public float Bounce{ get { | ||
2570 | if (HasBounce) { | ||
2571 | return PBJ._PBJ.CastFloat(super.Bounce); | ||
2572 | } else { | ||
2573 | return PBJ._PBJ.CastFloat(); | ||
2574 | } | ||
2575 | } | ||
2576 | } | ||
2577 | public const int HullFieldTag=6; | ||
2578 | public bool HasHull{ get {return super.HullCount>=3;} } | ||
2579 | public PBJ.Vector3f Hull{ get { | ||
2580 | int index=0; | ||
2581 | if (HasHull) { | ||
2582 | return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2)); | ||
2583 | } else { | ||
2584 | return PBJ._PBJ.CastVector3f(); | ||
2585 | } | ||
2586 | } | ||
2587 | } | ||
2588 | public const int CollideMsgFieldTag=16; | ||
2589 | public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} } | ||
2590 | public uint CollideMsg{ get { | ||
2591 | if (HasCollideMsg) { | ||
2592 | return PBJ._PBJ.CastUint32(super.CollideMsg); | ||
2593 | } else { | ||
2594 | return PBJ._PBJ.CastUint32(); | ||
2595 | } | ||
2596 | } | ||
2597 | } | ||
2598 | public const int CollideMaskFieldTag=17; | ||
2599 | public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} } | ||
2600 | public uint CollideMask{ get { | ||
2601 | if (HasCollideMask) { | ||
2602 | return PBJ._PBJ.CastUint32(super.CollideMask); | ||
2603 | } else { | ||
2604 | return PBJ._PBJ.CastUint32(); | ||
2605 | } | ||
2606 | } | ||
2607 | } | ||
2608 | public const int GravityFieldTag=18; | ||
2609 | public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} } | ||
2610 | public float Gravity{ get { | ||
2611 | if (HasGravity) { | ||
2612 | return PBJ._PBJ.CastFloat(super.Gravity); | ||
2613 | } else { | ||
2614 | return PBJ._PBJ.CastFloat(); | ||
2615 | } | ||
2616 | } | ||
2617 | } | ||
2618 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
2619 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
2620 | public static Builder CreateBuilder() { return new Builder(); } | ||
2621 | public static Builder CreateBuilder(PhysicalParameters prototype) { | ||
2622 | return (Builder)new Builder().MergeFrom(prototype); | ||
2623 | } | ||
2624 | public static PhysicalParameters ParseFrom(pb::ByteString data) { | ||
2625 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); | ||
2626 | } | ||
2627 | public static PhysicalParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
2628 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); | ||
2629 | } | ||
2630 | public static PhysicalParameters ParseFrom(byte[] data) { | ||
2631 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); | ||
2632 | } | ||
2633 | public static PhysicalParameters ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
2634 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); | ||
2635 | } | ||
2636 | public static PhysicalParameters ParseFrom(global::System.IO.Stream data) { | ||
2637 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); | ||
2638 | } | ||
2639 | public static PhysicalParameters ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
2640 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); | ||
2641 | } | ||
2642 | public static PhysicalParameters ParseFrom(pb::CodedInputStream data) { | ||
2643 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data)); | ||
2644 | } | ||
2645 | public static PhysicalParameters ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
2646 | return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er)); | ||
2647 | } | ||
2648 | protected override bool _HasAllPBJFields{ get { | ||
2649 | return true | ||
2650 | ; | ||
2651 | } } | ||
2652 | public bool IsInitialized { get { | ||
2653 | return super.IsInitialized&&_HasAllPBJFields; | ||
2654 | } } | ||
2655 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
2656 | protected override bool _HasAllPBJFields{ get { | ||
2657 | return true | ||
2658 | ; | ||
2659 | } } | ||
2660 | public bool IsInitialized { get { | ||
2661 | return super.IsInitialized&&_HasAllPBJFields; | ||
2662 | } } | ||
2663 | protected _PBJ_Internal.PhysicalParameters.Builder super; | ||
2664 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
2665 | public _PBJ_Internal.PhysicalParameters.Builder _PBJSuper{ get { return super;} } | ||
2666 | public Builder() {super = new _PBJ_Internal.PhysicalParameters.Builder();} | ||
2667 | public Builder(_PBJ_Internal.PhysicalParameters.Builder other) { | ||
2668 | super=other; | ||
2669 | } | ||
2670 | public Builder Clone() {return new Builder(super.Clone());} | ||
2671 | public Builder MergeFrom(PhysicalParameters prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
2672 | public Builder Clear() {super.Clear();return this;} | ||
2673 | public PhysicalParameters BuildPartial() {return new PhysicalParameters(super.BuildPartial());} | ||
2674 | public PhysicalParameters Build() {if (_HasAllPBJFields) return new PhysicalParameters(super.Build());return null;} | ||
2675 | public pbd::MessageDescriptor DescriptorForType { | ||
2676 | get { return PhysicalParameters.Descriptor; } } | ||
2677 | public Builder ClearMode() { super.ClearMode();return this;} | ||
2678 | public const int ModeFieldTag=2; | ||
2679 | public bool HasMode{ get {return super.HasMode;} } | ||
2680 | public Types.Mode Mode{ get { | ||
2681 | if (HasMode) { | ||
2682 | return (Types.Mode)super.Mode; | ||
2683 | } else { | ||
2684 | return new Types.Mode(); | ||
2685 | } | ||
2686 | } | ||
2687 | set { | ||
2688 | super.Mode=((_PBJ_Internal.PhysicalParameters.Types.Mode)value); | ||
2689 | } | ||
2690 | } | ||
2691 | public Builder ClearDensity() { super.ClearDensity();return this;} | ||
2692 | public const int DensityFieldTag=3; | ||
2693 | public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} } | ||
2694 | public float Density{ get { | ||
2695 | if (HasDensity) { | ||
2696 | return PBJ._PBJ.CastFloat(super.Density); | ||
2697 | } else { | ||
2698 | return PBJ._PBJ.CastFloat(); | ||
2699 | } | ||
2700 | } | ||
2701 | set { | ||
2702 | super.Density=(PBJ._PBJ.Construct(value)); | ||
2703 | } | ||
2704 | } | ||
2705 | public Builder ClearFriction() { super.ClearFriction();return this;} | ||
2706 | public const int FrictionFieldTag=4; | ||
2707 | public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} } | ||
2708 | public float Friction{ get { | ||
2709 | if (HasFriction) { | ||
2710 | return PBJ._PBJ.CastFloat(super.Friction); | ||
2711 | } else { | ||
2712 | return PBJ._PBJ.CastFloat(); | ||
2713 | } | ||
2714 | } | ||
2715 | set { | ||
2716 | super.Friction=(PBJ._PBJ.Construct(value)); | ||
2717 | } | ||
2718 | } | ||
2719 | public Builder ClearBounce() { super.ClearBounce();return this;} | ||
2720 | public const int BounceFieldTag=5; | ||
2721 | public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} } | ||
2722 | public float Bounce{ get { | ||
2723 | if (HasBounce) { | ||
2724 | return PBJ._PBJ.CastFloat(super.Bounce); | ||
2725 | } else { | ||
2726 | return PBJ._PBJ.CastFloat(); | ||
2727 | } | ||
2728 | } | ||
2729 | set { | ||
2730 | super.Bounce=(PBJ._PBJ.Construct(value)); | ||
2731 | } | ||
2732 | } | ||
2733 | public Builder ClearHull() { super.ClearHull();return this;} | ||
2734 | public const int HullFieldTag=6; | ||
2735 | public bool HasHull{ get {return super.HullCount>=3;} } | ||
2736 | public PBJ.Vector3f Hull{ get { | ||
2737 | int index=0; | ||
2738 | if (HasHull) { | ||
2739 | return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2)); | ||
2740 | } else { | ||
2741 | return PBJ._PBJ.CastVector3f(); | ||
2742 | } | ||
2743 | } | ||
2744 | set { | ||
2745 | super.ClearHull(); | ||
2746 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
2747 | super.AddHull(_PBJtempArray[0]); | ||
2748 | super.AddHull(_PBJtempArray[1]); | ||
2749 | super.AddHull(_PBJtempArray[2]); | ||
2750 | } | ||
2751 | } | ||
2752 | public Builder ClearCollideMsg() { super.ClearCollideMsg();return this;} | ||
2753 | public const int CollideMsgFieldTag=16; | ||
2754 | public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} } | ||
2755 | public uint CollideMsg{ get { | ||
2756 | if (HasCollideMsg) { | ||
2757 | return PBJ._PBJ.CastUint32(super.CollideMsg); | ||
2758 | } else { | ||
2759 | return PBJ._PBJ.CastUint32(); | ||
2760 | } | ||
2761 | } | ||
2762 | set { | ||
2763 | super.CollideMsg=(PBJ._PBJ.Construct(value)); | ||
2764 | } | ||
2765 | } | ||
2766 | public Builder ClearCollideMask() { super.ClearCollideMask();return this;} | ||
2767 | public const int CollideMaskFieldTag=17; | ||
2768 | public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} } | ||
2769 | public uint CollideMask{ get { | ||
2770 | if (HasCollideMask) { | ||
2771 | return PBJ._PBJ.CastUint32(super.CollideMask); | ||
2772 | } else { | ||
2773 | return PBJ._PBJ.CastUint32(); | ||
2774 | } | ||
2775 | } | ||
2776 | set { | ||
2777 | super.CollideMask=(PBJ._PBJ.Construct(value)); | ||
2778 | } | ||
2779 | } | ||
2780 | public Builder ClearGravity() { super.ClearGravity();return this;} | ||
2781 | public const int GravityFieldTag=18; | ||
2782 | public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} } | ||
2783 | public float Gravity{ get { | ||
2784 | if (HasGravity) { | ||
2785 | return PBJ._PBJ.CastFloat(super.Gravity); | ||
2786 | } else { | ||
2787 | return PBJ._PBJ.CastFloat(); | ||
2788 | } | ||
2789 | } | ||
2790 | set { | ||
2791 | super.Gravity=(PBJ._PBJ.Construct(value)); | ||
2792 | } | ||
2793 | } | ||
2794 | } | ||
2795 | } | ||
2796 | } | ||
2797 | namespace Sirikata.Protocol { | ||
2798 | public class LightInfoProperty : PBJ.IMessage { | ||
2799 | protected _PBJ_Internal.LightInfoProperty super; | ||
2800 | public _PBJ_Internal.LightInfoProperty _PBJSuper{ get { return super;} } | ||
2801 | public LightInfoProperty() { | ||
2802 | super=new _PBJ_Internal.LightInfoProperty(); | ||
2803 | } | ||
2804 | public LightInfoProperty(_PBJ_Internal.LightInfoProperty reference) { | ||
2805 | super=reference; | ||
2806 | } | ||
2807 | public static LightInfoProperty defaultInstance= new LightInfoProperty (_PBJ_Internal.LightInfoProperty.DefaultInstance); | ||
2808 | public static LightInfoProperty DefaultInstance{ | ||
2809 | get {return defaultInstance;} | ||
2810 | } | ||
2811 | public static pbd.MessageDescriptor Descriptor { | ||
2812 | get { return _PBJ_Internal.LightInfoProperty.Descriptor; } } | ||
2813 | public static class Types { | ||
2814 | public enum LightTypes { | ||
2815 | POINT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT, | ||
2816 | SPOTLIGHT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.SPOTLIGHT, | ||
2817 | DIRECTIONAL=_PBJ_Internal.LightInfoProperty.Types.LightTypes.DIRECTIONAL | ||
2818 | }; | ||
2819 | } | ||
2820 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
2821 | return false; | ||
2822 | } | ||
2823 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
2824 | return false; | ||
2825 | } | ||
2826 | public const int DiffuseColorFieldTag=3; | ||
2827 | public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} } | ||
2828 | public PBJ.Vector3f DiffuseColor{ get { | ||
2829 | int index=0; | ||
2830 | if (HasDiffuseColor) { | ||
2831 | return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2)); | ||
2832 | } else { | ||
2833 | return PBJ._PBJ.CastVector3f(); | ||
2834 | } | ||
2835 | } | ||
2836 | } | ||
2837 | public const int SpecularColorFieldTag=4; | ||
2838 | public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} } | ||
2839 | public PBJ.Vector3f SpecularColor{ get { | ||
2840 | int index=0; | ||
2841 | if (HasSpecularColor) { | ||
2842 | return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2)); | ||
2843 | } else { | ||
2844 | return PBJ._PBJ.CastVector3f(); | ||
2845 | } | ||
2846 | } | ||
2847 | } | ||
2848 | public const int PowerFieldTag=5; | ||
2849 | public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} } | ||
2850 | public float Power{ get { | ||
2851 | if (HasPower) { | ||
2852 | return PBJ._PBJ.CastFloat(super.Power); | ||
2853 | } else { | ||
2854 | return PBJ._PBJ.CastFloat(); | ||
2855 | } | ||
2856 | } | ||
2857 | } | ||
2858 | public const int AmbientColorFieldTag=6; | ||
2859 | public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} } | ||
2860 | public PBJ.Vector3f AmbientColor{ get { | ||
2861 | int index=0; | ||
2862 | if (HasAmbientColor) { | ||
2863 | return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2)); | ||
2864 | } else { | ||
2865 | return PBJ._PBJ.CastVector3f(); | ||
2866 | } | ||
2867 | } | ||
2868 | } | ||
2869 | public const int ShadowColorFieldTag=7; | ||
2870 | public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} } | ||
2871 | public PBJ.Vector3f ShadowColor{ get { | ||
2872 | int index=0; | ||
2873 | if (HasShadowColor) { | ||
2874 | return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2)); | ||
2875 | } else { | ||
2876 | return PBJ._PBJ.CastVector3f(); | ||
2877 | } | ||
2878 | } | ||
2879 | } | ||
2880 | public const int LightRangeFieldTag=8; | ||
2881 | public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} } | ||
2882 | public double LightRange{ get { | ||
2883 | if (HasLightRange) { | ||
2884 | return PBJ._PBJ.CastDouble(super.LightRange); | ||
2885 | } else { | ||
2886 | return PBJ._PBJ.CastDouble(); | ||
2887 | } | ||
2888 | } | ||
2889 | } | ||
2890 | public const int ConstantFalloffFieldTag=9; | ||
2891 | public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} } | ||
2892 | public float ConstantFalloff{ get { | ||
2893 | if (HasConstantFalloff) { | ||
2894 | return PBJ._PBJ.CastFloat(super.ConstantFalloff); | ||
2895 | } else { | ||
2896 | return PBJ._PBJ.CastFloat(); | ||
2897 | } | ||
2898 | } | ||
2899 | } | ||
2900 | public const int LinearFalloffFieldTag=10; | ||
2901 | public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} } | ||
2902 | public float LinearFalloff{ get { | ||
2903 | if (HasLinearFalloff) { | ||
2904 | return PBJ._PBJ.CastFloat(super.LinearFalloff); | ||
2905 | } else { | ||
2906 | return PBJ._PBJ.CastFloat(); | ||
2907 | } | ||
2908 | } | ||
2909 | } | ||
2910 | public const int QuadraticFalloffFieldTag=11; | ||
2911 | public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} } | ||
2912 | public float QuadraticFalloff{ get { | ||
2913 | if (HasQuadraticFalloff) { | ||
2914 | return PBJ._PBJ.CastFloat(super.QuadraticFalloff); | ||
2915 | } else { | ||
2916 | return PBJ._PBJ.CastFloat(); | ||
2917 | } | ||
2918 | } | ||
2919 | } | ||
2920 | public const int ConeInnerRadiansFieldTag=12; | ||
2921 | public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} } | ||
2922 | public float ConeInnerRadians{ get { | ||
2923 | if (HasConeInnerRadians) { | ||
2924 | return PBJ._PBJ.CastFloat(super.ConeInnerRadians); | ||
2925 | } else { | ||
2926 | return PBJ._PBJ.CastFloat(); | ||
2927 | } | ||
2928 | } | ||
2929 | } | ||
2930 | public const int ConeOuterRadiansFieldTag=13; | ||
2931 | public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} } | ||
2932 | public float ConeOuterRadians{ get { | ||
2933 | if (HasConeOuterRadians) { | ||
2934 | return PBJ._PBJ.CastFloat(super.ConeOuterRadians); | ||
2935 | } else { | ||
2936 | return PBJ._PBJ.CastFloat(); | ||
2937 | } | ||
2938 | } | ||
2939 | } | ||
2940 | public const int ConeFalloffFieldTag=14; | ||
2941 | public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} } | ||
2942 | public float ConeFalloff{ get { | ||
2943 | if (HasConeFalloff) { | ||
2944 | return PBJ._PBJ.CastFloat(super.ConeFalloff); | ||
2945 | } else { | ||
2946 | return PBJ._PBJ.CastFloat(); | ||
2947 | } | ||
2948 | } | ||
2949 | } | ||
2950 | public const int TypeFieldTag=15; | ||
2951 | public bool HasType{ get {return super.HasType;} } | ||
2952 | public Types.LightTypes Type{ get { | ||
2953 | if (HasType) { | ||
2954 | return (Types.LightTypes)super.Type; | ||
2955 | } else { | ||
2956 | return new Types.LightTypes(); | ||
2957 | } | ||
2958 | } | ||
2959 | } | ||
2960 | public const int CastsShadowFieldTag=16; | ||
2961 | public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} } | ||
2962 | public bool CastsShadow{ get { | ||
2963 | if (HasCastsShadow) { | ||
2964 | return PBJ._PBJ.CastBool(super.CastsShadow); | ||
2965 | } else { | ||
2966 | return PBJ._PBJ.CastBool(); | ||
2967 | } | ||
2968 | } | ||
2969 | } | ||
2970 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
2971 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
2972 | public static Builder CreateBuilder() { return new Builder(); } | ||
2973 | public static Builder CreateBuilder(LightInfoProperty prototype) { | ||
2974 | return (Builder)new Builder().MergeFrom(prototype); | ||
2975 | } | ||
2976 | public static LightInfoProperty ParseFrom(pb::ByteString data) { | ||
2977 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); | ||
2978 | } | ||
2979 | public static LightInfoProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
2980 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); | ||
2981 | } | ||
2982 | public static LightInfoProperty ParseFrom(byte[] data) { | ||
2983 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); | ||
2984 | } | ||
2985 | public static LightInfoProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
2986 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); | ||
2987 | } | ||
2988 | public static LightInfoProperty ParseFrom(global::System.IO.Stream data) { | ||
2989 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); | ||
2990 | } | ||
2991 | public static LightInfoProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
2992 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); | ||
2993 | } | ||
2994 | public static LightInfoProperty ParseFrom(pb::CodedInputStream data) { | ||
2995 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data)); | ||
2996 | } | ||
2997 | public static LightInfoProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
2998 | return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er)); | ||
2999 | } | ||
3000 | protected override bool _HasAllPBJFields{ get { | ||
3001 | return true | ||
3002 | ; | ||
3003 | } } | ||
3004 | public bool IsInitialized { get { | ||
3005 | return super.IsInitialized&&_HasAllPBJFields; | ||
3006 | } } | ||
3007 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
3008 | protected override bool _HasAllPBJFields{ get { | ||
3009 | return true | ||
3010 | ; | ||
3011 | } } | ||
3012 | public bool IsInitialized { get { | ||
3013 | return super.IsInitialized&&_HasAllPBJFields; | ||
3014 | } } | ||
3015 | protected _PBJ_Internal.LightInfoProperty.Builder super; | ||
3016 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
3017 | public _PBJ_Internal.LightInfoProperty.Builder _PBJSuper{ get { return super;} } | ||
3018 | public Builder() {super = new _PBJ_Internal.LightInfoProperty.Builder();} | ||
3019 | public Builder(_PBJ_Internal.LightInfoProperty.Builder other) { | ||
3020 | super=other; | ||
3021 | } | ||
3022 | public Builder Clone() {return new Builder(super.Clone());} | ||
3023 | public Builder MergeFrom(LightInfoProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
3024 | public Builder Clear() {super.Clear();return this;} | ||
3025 | public LightInfoProperty BuildPartial() {return new LightInfoProperty(super.BuildPartial());} | ||
3026 | public LightInfoProperty Build() {if (_HasAllPBJFields) return new LightInfoProperty(super.Build());return null;} | ||
3027 | public pbd::MessageDescriptor DescriptorForType { | ||
3028 | get { return LightInfoProperty.Descriptor; } } | ||
3029 | public Builder ClearDiffuseColor() { super.ClearDiffuseColor();return this;} | ||
3030 | public const int DiffuseColorFieldTag=3; | ||
3031 | public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} } | ||
3032 | public PBJ.Vector3f DiffuseColor{ get { | ||
3033 | int index=0; | ||
3034 | if (HasDiffuseColor) { | ||
3035 | return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2)); | ||
3036 | } else { | ||
3037 | return PBJ._PBJ.CastVector3f(); | ||
3038 | } | ||
3039 | } | ||
3040 | set { | ||
3041 | super.ClearDiffuseColor(); | ||
3042 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
3043 | super.AddDiffuseColor(_PBJtempArray[0]); | ||
3044 | super.AddDiffuseColor(_PBJtempArray[1]); | ||
3045 | super.AddDiffuseColor(_PBJtempArray[2]); | ||
3046 | } | ||
3047 | } | ||
3048 | public Builder ClearSpecularColor() { super.ClearSpecularColor();return this;} | ||
3049 | public const int SpecularColorFieldTag=4; | ||
3050 | public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} } | ||
3051 | public PBJ.Vector3f SpecularColor{ get { | ||
3052 | int index=0; | ||
3053 | if (HasSpecularColor) { | ||
3054 | return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2)); | ||
3055 | } else { | ||
3056 | return PBJ._PBJ.CastVector3f(); | ||
3057 | } | ||
3058 | } | ||
3059 | set { | ||
3060 | super.ClearSpecularColor(); | ||
3061 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
3062 | super.AddSpecularColor(_PBJtempArray[0]); | ||
3063 | super.AddSpecularColor(_PBJtempArray[1]); | ||
3064 | super.AddSpecularColor(_PBJtempArray[2]); | ||
3065 | } | ||
3066 | } | ||
3067 | public Builder ClearPower() { super.ClearPower();return this;} | ||
3068 | public const int PowerFieldTag=5; | ||
3069 | public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} } | ||
3070 | public float Power{ get { | ||
3071 | if (HasPower) { | ||
3072 | return PBJ._PBJ.CastFloat(super.Power); | ||
3073 | } else { | ||
3074 | return PBJ._PBJ.CastFloat(); | ||
3075 | } | ||
3076 | } | ||
3077 | set { | ||
3078 | super.Power=(PBJ._PBJ.Construct(value)); | ||
3079 | } | ||
3080 | } | ||
3081 | public Builder ClearAmbientColor() { super.ClearAmbientColor();return this;} | ||
3082 | public const int AmbientColorFieldTag=6; | ||
3083 | public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} } | ||
3084 | public PBJ.Vector3f AmbientColor{ get { | ||
3085 | int index=0; | ||
3086 | if (HasAmbientColor) { | ||
3087 | return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2)); | ||
3088 | } else { | ||
3089 | return PBJ._PBJ.CastVector3f(); | ||
3090 | } | ||
3091 | } | ||
3092 | set { | ||
3093 | super.ClearAmbientColor(); | ||
3094 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
3095 | super.AddAmbientColor(_PBJtempArray[0]); | ||
3096 | super.AddAmbientColor(_PBJtempArray[1]); | ||
3097 | super.AddAmbientColor(_PBJtempArray[2]); | ||
3098 | } | ||
3099 | } | ||
3100 | public Builder ClearShadowColor() { super.ClearShadowColor();return this;} | ||
3101 | public const int ShadowColorFieldTag=7; | ||
3102 | public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} } | ||
3103 | public PBJ.Vector3f ShadowColor{ get { | ||
3104 | int index=0; | ||
3105 | if (HasShadowColor) { | ||
3106 | return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2)); | ||
3107 | } else { | ||
3108 | return PBJ._PBJ.CastVector3f(); | ||
3109 | } | ||
3110 | } | ||
3111 | set { | ||
3112 | super.ClearShadowColor(); | ||
3113 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
3114 | super.AddShadowColor(_PBJtempArray[0]); | ||
3115 | super.AddShadowColor(_PBJtempArray[1]); | ||
3116 | super.AddShadowColor(_PBJtempArray[2]); | ||
3117 | } | ||
3118 | } | ||
3119 | public Builder ClearLightRange() { super.ClearLightRange();return this;} | ||
3120 | public const int LightRangeFieldTag=8; | ||
3121 | public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} } | ||
3122 | public double LightRange{ get { | ||
3123 | if (HasLightRange) { | ||
3124 | return PBJ._PBJ.CastDouble(super.LightRange); | ||
3125 | } else { | ||
3126 | return PBJ._PBJ.CastDouble(); | ||
3127 | } | ||
3128 | } | ||
3129 | set { | ||
3130 | super.LightRange=(PBJ._PBJ.Construct(value)); | ||
3131 | } | ||
3132 | } | ||
3133 | public Builder ClearConstantFalloff() { super.ClearConstantFalloff();return this;} | ||
3134 | public const int ConstantFalloffFieldTag=9; | ||
3135 | public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} } | ||
3136 | public float ConstantFalloff{ get { | ||
3137 | if (HasConstantFalloff) { | ||
3138 | return PBJ._PBJ.CastFloat(super.ConstantFalloff); | ||
3139 | } else { | ||
3140 | return PBJ._PBJ.CastFloat(); | ||
3141 | } | ||
3142 | } | ||
3143 | set { | ||
3144 | super.ConstantFalloff=(PBJ._PBJ.Construct(value)); | ||
3145 | } | ||
3146 | } | ||
3147 | public Builder ClearLinearFalloff() { super.ClearLinearFalloff();return this;} | ||
3148 | public const int LinearFalloffFieldTag=10; | ||
3149 | public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} } | ||
3150 | public float LinearFalloff{ get { | ||
3151 | if (HasLinearFalloff) { | ||
3152 | return PBJ._PBJ.CastFloat(super.LinearFalloff); | ||
3153 | } else { | ||
3154 | return PBJ._PBJ.CastFloat(); | ||
3155 | } | ||
3156 | } | ||
3157 | set { | ||
3158 | super.LinearFalloff=(PBJ._PBJ.Construct(value)); | ||
3159 | } | ||
3160 | } | ||
3161 | public Builder ClearQuadraticFalloff() { super.ClearQuadraticFalloff();return this;} | ||
3162 | public const int QuadraticFalloffFieldTag=11; | ||
3163 | public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} } | ||
3164 | public float QuadraticFalloff{ get { | ||
3165 | if (HasQuadraticFalloff) { | ||
3166 | return PBJ._PBJ.CastFloat(super.QuadraticFalloff); | ||
3167 | } else { | ||
3168 | return PBJ._PBJ.CastFloat(); | ||
3169 | } | ||
3170 | } | ||
3171 | set { | ||
3172 | super.QuadraticFalloff=(PBJ._PBJ.Construct(value)); | ||
3173 | } | ||
3174 | } | ||
3175 | public Builder ClearConeInnerRadians() { super.ClearConeInnerRadians();return this;} | ||
3176 | public const int ConeInnerRadiansFieldTag=12; | ||
3177 | public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} } | ||
3178 | public float ConeInnerRadians{ get { | ||
3179 | if (HasConeInnerRadians) { | ||
3180 | return PBJ._PBJ.CastFloat(super.ConeInnerRadians); | ||
3181 | } else { | ||
3182 | return PBJ._PBJ.CastFloat(); | ||
3183 | } | ||
3184 | } | ||
3185 | set { | ||
3186 | super.ConeInnerRadians=(PBJ._PBJ.Construct(value)); | ||
3187 | } | ||
3188 | } | ||
3189 | public Builder ClearConeOuterRadians() { super.ClearConeOuterRadians();return this;} | ||
3190 | public const int ConeOuterRadiansFieldTag=13; | ||
3191 | public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} } | ||
3192 | public float ConeOuterRadians{ get { | ||
3193 | if (HasConeOuterRadians) { | ||
3194 | return PBJ._PBJ.CastFloat(super.ConeOuterRadians); | ||
3195 | } else { | ||
3196 | return PBJ._PBJ.CastFloat(); | ||
3197 | } | ||
3198 | } | ||
3199 | set { | ||
3200 | super.ConeOuterRadians=(PBJ._PBJ.Construct(value)); | ||
3201 | } | ||
3202 | } | ||
3203 | public Builder ClearConeFalloff() { super.ClearConeFalloff();return this;} | ||
3204 | public const int ConeFalloffFieldTag=14; | ||
3205 | public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} } | ||
3206 | public float ConeFalloff{ get { | ||
3207 | if (HasConeFalloff) { | ||
3208 | return PBJ._PBJ.CastFloat(super.ConeFalloff); | ||
3209 | } else { | ||
3210 | return PBJ._PBJ.CastFloat(); | ||
3211 | } | ||
3212 | } | ||
3213 | set { | ||
3214 | super.ConeFalloff=(PBJ._PBJ.Construct(value)); | ||
3215 | } | ||
3216 | } | ||
3217 | public Builder ClearType() { super.ClearType();return this;} | ||
3218 | public const int TypeFieldTag=15; | ||
3219 | public bool HasType{ get {return super.HasType;} } | ||
3220 | public Types.LightTypes Type{ get { | ||
3221 | if (HasType) { | ||
3222 | return (Types.LightTypes)super.Type; | ||
3223 | } else { | ||
3224 | return new Types.LightTypes(); | ||
3225 | } | ||
3226 | } | ||
3227 | set { | ||
3228 | super.Type=((_PBJ_Internal.LightInfoProperty.Types.LightTypes)value); | ||
3229 | } | ||
3230 | } | ||
3231 | public Builder ClearCastsShadow() { super.ClearCastsShadow();return this;} | ||
3232 | public const int CastsShadowFieldTag=16; | ||
3233 | public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} } | ||
3234 | public bool CastsShadow{ get { | ||
3235 | if (HasCastsShadow) { | ||
3236 | return PBJ._PBJ.CastBool(super.CastsShadow); | ||
3237 | } else { | ||
3238 | return PBJ._PBJ.CastBool(); | ||
3239 | } | ||
3240 | } | ||
3241 | set { | ||
3242 | super.CastsShadow=(PBJ._PBJ.Construct(value)); | ||
3243 | } | ||
3244 | } | ||
3245 | } | ||
3246 | } | ||
3247 | } | ||
3248 | namespace Sirikata.Protocol { | ||
3249 | public class ParentProperty : PBJ.IMessage { | ||
3250 | protected _PBJ_Internal.ParentProperty super; | ||
3251 | public _PBJ_Internal.ParentProperty _PBJSuper{ get { return super;} } | ||
3252 | public ParentProperty() { | ||
3253 | super=new _PBJ_Internal.ParentProperty(); | ||
3254 | } | ||
3255 | public ParentProperty(_PBJ_Internal.ParentProperty reference) { | ||
3256 | super=reference; | ||
3257 | } | ||
3258 | public static ParentProperty defaultInstance= new ParentProperty (_PBJ_Internal.ParentProperty.DefaultInstance); | ||
3259 | public static ParentProperty DefaultInstance{ | ||
3260 | get {return defaultInstance;} | ||
3261 | } | ||
3262 | public static pbd.MessageDescriptor Descriptor { | ||
3263 | get { return _PBJ_Internal.ParentProperty.Descriptor; } } | ||
3264 | public static class Types { | ||
3265 | } | ||
3266 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
3267 | return false; | ||
3268 | } | ||
3269 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
3270 | return false; | ||
3271 | } | ||
3272 | public const int ValueFieldTag=10; | ||
3273 | public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} } | ||
3274 | public PBJ.UUID Value{ get { | ||
3275 | if (HasValue) { | ||
3276 | return PBJ._PBJ.CastUuid(super.Value); | ||
3277 | } else { | ||
3278 | return PBJ._PBJ.CastUuid(); | ||
3279 | } | ||
3280 | } | ||
3281 | } | ||
3282 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
3283 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
3284 | public static Builder CreateBuilder() { return new Builder(); } | ||
3285 | public static Builder CreateBuilder(ParentProperty prototype) { | ||
3286 | return (Builder)new Builder().MergeFrom(prototype); | ||
3287 | } | ||
3288 | public static ParentProperty ParseFrom(pb::ByteString data) { | ||
3289 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); | ||
3290 | } | ||
3291 | public static ParentProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
3292 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); | ||
3293 | } | ||
3294 | public static ParentProperty ParseFrom(byte[] data) { | ||
3295 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); | ||
3296 | } | ||
3297 | public static ParentProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
3298 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); | ||
3299 | } | ||
3300 | public static ParentProperty ParseFrom(global::System.IO.Stream data) { | ||
3301 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); | ||
3302 | } | ||
3303 | public static ParentProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
3304 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); | ||
3305 | } | ||
3306 | public static ParentProperty ParseFrom(pb::CodedInputStream data) { | ||
3307 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data)); | ||
3308 | } | ||
3309 | public static ParentProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
3310 | return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er)); | ||
3311 | } | ||
3312 | protected override bool _HasAllPBJFields{ get { | ||
3313 | return true | ||
3314 | ; | ||
3315 | } } | ||
3316 | public bool IsInitialized { get { | ||
3317 | return super.IsInitialized&&_HasAllPBJFields; | ||
3318 | } } | ||
3319 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
3320 | protected override bool _HasAllPBJFields{ get { | ||
3321 | return true | ||
3322 | ; | ||
3323 | } } | ||
3324 | public bool IsInitialized { get { | ||
3325 | return super.IsInitialized&&_HasAllPBJFields; | ||
3326 | } } | ||
3327 | protected _PBJ_Internal.ParentProperty.Builder super; | ||
3328 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
3329 | public _PBJ_Internal.ParentProperty.Builder _PBJSuper{ get { return super;} } | ||
3330 | public Builder() {super = new _PBJ_Internal.ParentProperty.Builder();} | ||
3331 | public Builder(_PBJ_Internal.ParentProperty.Builder other) { | ||
3332 | super=other; | ||
3333 | } | ||
3334 | public Builder Clone() {return new Builder(super.Clone());} | ||
3335 | public Builder MergeFrom(ParentProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
3336 | public Builder Clear() {super.Clear();return this;} | ||
3337 | public ParentProperty BuildPartial() {return new ParentProperty(super.BuildPartial());} | ||
3338 | public ParentProperty Build() {if (_HasAllPBJFields) return new ParentProperty(super.Build());return null;} | ||
3339 | public pbd::MessageDescriptor DescriptorForType { | ||
3340 | get { return ParentProperty.Descriptor; } } | ||
3341 | public Builder ClearValue() { super.ClearValue();return this;} | ||
3342 | public const int ValueFieldTag=10; | ||
3343 | public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} } | ||
3344 | public PBJ.UUID Value{ get { | ||
3345 | if (HasValue) { | ||
3346 | return PBJ._PBJ.CastUuid(super.Value); | ||
3347 | } else { | ||
3348 | return PBJ._PBJ.CastUuid(); | ||
3349 | } | ||
3350 | } | ||
3351 | set { | ||
3352 | super.Value=(PBJ._PBJ.Construct(value)); | ||
3353 | } | ||
3354 | } | ||
3355 | } | ||
3356 | } | ||
3357 | } | ||
3358 | namespace Sirikata.Protocol { | ||
3359 | public class UUIDListProperty : PBJ.IMessage { | ||
3360 | protected _PBJ_Internal.UUIDListProperty super; | ||
3361 | public _PBJ_Internal.UUIDListProperty _PBJSuper{ get { return super;} } | ||
3362 | public UUIDListProperty() { | ||
3363 | super=new _PBJ_Internal.UUIDListProperty(); | ||
3364 | } | ||
3365 | public UUIDListProperty(_PBJ_Internal.UUIDListProperty reference) { | ||
3366 | super=reference; | ||
3367 | } | ||
3368 | public static UUIDListProperty defaultInstance= new UUIDListProperty (_PBJ_Internal.UUIDListProperty.DefaultInstance); | ||
3369 | public static UUIDListProperty DefaultInstance{ | ||
3370 | get {return defaultInstance;} | ||
3371 | } | ||
3372 | public static pbd.MessageDescriptor Descriptor { | ||
3373 | get { return _PBJ_Internal.UUIDListProperty.Descriptor; } } | ||
3374 | public static class Types { | ||
3375 | } | ||
3376 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
3377 | return false; | ||
3378 | } | ||
3379 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
3380 | return false; | ||
3381 | } | ||
3382 | public const int ValueFieldTag=10; | ||
3383 | public int ValueCount { get { return super.ValueCount;} } | ||
3384 | public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));} | ||
3385 | public PBJ.UUID Value(int index) { | ||
3386 | return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index)); | ||
3387 | } | ||
3388 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
3389 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
3390 | public static Builder CreateBuilder() { return new Builder(); } | ||
3391 | public static Builder CreateBuilder(UUIDListProperty prototype) { | ||
3392 | return (Builder)new Builder().MergeFrom(prototype); | ||
3393 | } | ||
3394 | public static UUIDListProperty ParseFrom(pb::ByteString data) { | ||
3395 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); | ||
3396 | } | ||
3397 | public static UUIDListProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
3398 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); | ||
3399 | } | ||
3400 | public static UUIDListProperty ParseFrom(byte[] data) { | ||
3401 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); | ||
3402 | } | ||
3403 | public static UUIDListProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
3404 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); | ||
3405 | } | ||
3406 | public static UUIDListProperty ParseFrom(global::System.IO.Stream data) { | ||
3407 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); | ||
3408 | } | ||
3409 | public static UUIDListProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
3410 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); | ||
3411 | } | ||
3412 | public static UUIDListProperty ParseFrom(pb::CodedInputStream data) { | ||
3413 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data)); | ||
3414 | } | ||
3415 | public static UUIDListProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
3416 | return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er)); | ||
3417 | } | ||
3418 | protected override bool _HasAllPBJFields{ get { | ||
3419 | return true | ||
3420 | ; | ||
3421 | } } | ||
3422 | public bool IsInitialized { get { | ||
3423 | return super.IsInitialized&&_HasAllPBJFields; | ||
3424 | } } | ||
3425 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
3426 | protected override bool _HasAllPBJFields{ get { | ||
3427 | return true | ||
3428 | ; | ||
3429 | } } | ||
3430 | public bool IsInitialized { get { | ||
3431 | return super.IsInitialized&&_HasAllPBJFields; | ||
3432 | } } | ||
3433 | protected _PBJ_Internal.UUIDListProperty.Builder super; | ||
3434 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
3435 | public _PBJ_Internal.UUIDListProperty.Builder _PBJSuper{ get { return super;} } | ||
3436 | public Builder() {super = new _PBJ_Internal.UUIDListProperty.Builder();} | ||
3437 | public Builder(_PBJ_Internal.UUIDListProperty.Builder other) { | ||
3438 | super=other; | ||
3439 | } | ||
3440 | public Builder Clone() {return new Builder(super.Clone());} | ||
3441 | public Builder MergeFrom(UUIDListProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
3442 | public Builder Clear() {super.Clear();return this;} | ||
3443 | public UUIDListProperty BuildPartial() {return new UUIDListProperty(super.BuildPartial());} | ||
3444 | public UUIDListProperty Build() {if (_HasAllPBJFields) return new UUIDListProperty(super.Build());return null;} | ||
3445 | public pbd::MessageDescriptor DescriptorForType { | ||
3446 | get { return UUIDListProperty.Descriptor; } } | ||
3447 | public Builder ClearValue() { super.ClearValue();return this;} | ||
3448 | public Builder SetValue(int index, PBJ.UUID value) { | ||
3449 | super.SetValue(index,PBJ._PBJ.Construct(value)); | ||
3450 | return this; | ||
3451 | } | ||
3452 | public const int ValueFieldTag=10; | ||
3453 | public int ValueCount { get { return super.ValueCount;} } | ||
3454 | public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));} | ||
3455 | public PBJ.UUID Value(int index) { | ||
3456 | return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index)); | ||
3457 | } | ||
3458 | public Builder AddValue(PBJ.UUID value) { | ||
3459 | super.AddValue(PBJ._PBJ.Construct(value)); | ||
3460 | return this; | ||
3461 | } | ||
3462 | } | ||
3463 | } | ||
3464 | } | ||
3465 | namespace Sirikata.Protocol { | ||
3466 | public class ConnectToSpace : PBJ.IMessage { | ||
3467 | protected _PBJ_Internal.ConnectToSpace super; | ||
3468 | public _PBJ_Internal.ConnectToSpace _PBJSuper{ get { return super;} } | ||
3469 | public ConnectToSpace() { | ||
3470 | super=new _PBJ_Internal.ConnectToSpace(); | ||
3471 | } | ||
3472 | public ConnectToSpace(_PBJ_Internal.ConnectToSpace reference) { | ||
3473 | super=reference; | ||
3474 | } | ||
3475 | public static ConnectToSpace defaultInstance= new ConnectToSpace (_PBJ_Internal.ConnectToSpace.DefaultInstance); | ||
3476 | public static ConnectToSpace DefaultInstance{ | ||
3477 | get {return defaultInstance;} | ||
3478 | } | ||
3479 | public static pbd.MessageDescriptor Descriptor { | ||
3480 | get { return _PBJ_Internal.ConnectToSpace.Descriptor; } } | ||
3481 | public static class Types { | ||
3482 | } | ||
3483 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
3484 | return false; | ||
3485 | } | ||
3486 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
3487 | return false; | ||
3488 | } | ||
3489 | public const int SpaceIdFieldTag=1; | ||
3490 | public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} } | ||
3491 | public PBJ.UUID SpaceId{ get { | ||
3492 | if (HasSpaceId) { | ||
3493 | return PBJ._PBJ.CastUuid(super.SpaceId); | ||
3494 | } else { | ||
3495 | return PBJ._PBJ.CastUuid(); | ||
3496 | } | ||
3497 | } | ||
3498 | } | ||
3499 | public const int ObjectUuidEvidenceFieldTag=2; | ||
3500 | public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } | ||
3501 | public PBJ.UUID ObjectUuidEvidence{ get { | ||
3502 | if (HasObjectUuidEvidence) { | ||
3503 | return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); | ||
3504 | } else { | ||
3505 | return PBJ._PBJ.CastUuid(); | ||
3506 | } | ||
3507 | } | ||
3508 | } | ||
3509 | public const int RequestedObjectLocFieldTag=3; | ||
3510 | public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } | ||
3511 | public ObjLoc RequestedObjectLoc{ get { | ||
3512 | if (HasRequestedObjectLoc) { | ||
3513 | return new ObjLoc(super.RequestedObjectLoc); | ||
3514 | } else { | ||
3515 | return new ObjLoc(); | ||
3516 | } | ||
3517 | } | ||
3518 | } | ||
3519 | public const int BoundingSphereFieldTag=4; | ||
3520 | public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } | ||
3521 | public PBJ.BoundingSphere3f BoundingSphere{ get { | ||
3522 | int index=0; | ||
3523 | if (HasBoundingSphere) { | ||
3524 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); | ||
3525 | } else { | ||
3526 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
3527 | } | ||
3528 | } | ||
3529 | } | ||
3530 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
3531 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
3532 | public static Builder CreateBuilder() { return new Builder(); } | ||
3533 | public static Builder CreateBuilder(ConnectToSpace prototype) { | ||
3534 | return (Builder)new Builder().MergeFrom(prototype); | ||
3535 | } | ||
3536 | public static ConnectToSpace ParseFrom(pb::ByteString data) { | ||
3537 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); | ||
3538 | } | ||
3539 | public static ConnectToSpace ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
3540 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); | ||
3541 | } | ||
3542 | public static ConnectToSpace ParseFrom(byte[] data) { | ||
3543 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); | ||
3544 | } | ||
3545 | public static ConnectToSpace ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
3546 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); | ||
3547 | } | ||
3548 | public static ConnectToSpace ParseFrom(global::System.IO.Stream data) { | ||
3549 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); | ||
3550 | } | ||
3551 | public static ConnectToSpace ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
3552 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); | ||
3553 | } | ||
3554 | public static ConnectToSpace ParseFrom(pb::CodedInputStream data) { | ||
3555 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data)); | ||
3556 | } | ||
3557 | public static ConnectToSpace ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
3558 | return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er)); | ||
3559 | } | ||
3560 | protected override bool _HasAllPBJFields{ get { | ||
3561 | return true | ||
3562 | ; | ||
3563 | } } | ||
3564 | public bool IsInitialized { get { | ||
3565 | return super.IsInitialized&&_HasAllPBJFields; | ||
3566 | } } | ||
3567 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
3568 | protected override bool _HasAllPBJFields{ get { | ||
3569 | return true | ||
3570 | ; | ||
3571 | } } | ||
3572 | public bool IsInitialized { get { | ||
3573 | return super.IsInitialized&&_HasAllPBJFields; | ||
3574 | } } | ||
3575 | protected _PBJ_Internal.ConnectToSpace.Builder super; | ||
3576 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
3577 | public _PBJ_Internal.ConnectToSpace.Builder _PBJSuper{ get { return super;} } | ||
3578 | public Builder() {super = new _PBJ_Internal.ConnectToSpace.Builder();} | ||
3579 | public Builder(_PBJ_Internal.ConnectToSpace.Builder other) { | ||
3580 | super=other; | ||
3581 | } | ||
3582 | public Builder Clone() {return new Builder(super.Clone());} | ||
3583 | public Builder MergeFrom(ConnectToSpace prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
3584 | public Builder Clear() {super.Clear();return this;} | ||
3585 | public ConnectToSpace BuildPartial() {return new ConnectToSpace(super.BuildPartial());} | ||
3586 | public ConnectToSpace Build() {if (_HasAllPBJFields) return new ConnectToSpace(super.Build());return null;} | ||
3587 | public pbd::MessageDescriptor DescriptorForType { | ||
3588 | get { return ConnectToSpace.Descriptor; } } | ||
3589 | public Builder ClearSpaceId() { super.ClearSpaceId();return this;} | ||
3590 | public const int SpaceIdFieldTag=1; | ||
3591 | public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} } | ||
3592 | public PBJ.UUID SpaceId{ get { | ||
3593 | if (HasSpaceId) { | ||
3594 | return PBJ._PBJ.CastUuid(super.SpaceId); | ||
3595 | } else { | ||
3596 | return PBJ._PBJ.CastUuid(); | ||
3597 | } | ||
3598 | } | ||
3599 | set { | ||
3600 | super.SpaceId=(PBJ._PBJ.Construct(value)); | ||
3601 | } | ||
3602 | } | ||
3603 | public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;} | ||
3604 | public const int ObjectUuidEvidenceFieldTag=2; | ||
3605 | public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} } | ||
3606 | public PBJ.UUID ObjectUuidEvidence{ get { | ||
3607 | if (HasObjectUuidEvidence) { | ||
3608 | return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence); | ||
3609 | } else { | ||
3610 | return PBJ._PBJ.CastUuid(); | ||
3611 | } | ||
3612 | } | ||
3613 | set { | ||
3614 | super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value)); | ||
3615 | } | ||
3616 | } | ||
3617 | public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;} | ||
3618 | public const int RequestedObjectLocFieldTag=3; | ||
3619 | public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} } | ||
3620 | public ObjLoc RequestedObjectLoc{ get { | ||
3621 | if (HasRequestedObjectLoc) { | ||
3622 | return new ObjLoc(super.RequestedObjectLoc); | ||
3623 | } else { | ||
3624 | return new ObjLoc(); | ||
3625 | } | ||
3626 | } | ||
3627 | set { | ||
3628 | super.RequestedObjectLoc=value._PBJSuper; | ||
3629 | } | ||
3630 | } | ||
3631 | public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;} | ||
3632 | public const int BoundingSphereFieldTag=4; | ||
3633 | public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} } | ||
3634 | public PBJ.BoundingSphere3f BoundingSphere{ get { | ||
3635 | int index=0; | ||
3636 | if (HasBoundingSphere) { | ||
3637 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3)); | ||
3638 | } else { | ||
3639 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
3640 | } | ||
3641 | } | ||
3642 | set { | ||
3643 | super.ClearBoundingSphere(); | ||
3644 | float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); | ||
3645 | super.AddBoundingSphere(_PBJtempArray[0]); | ||
3646 | super.AddBoundingSphere(_PBJtempArray[1]); | ||
3647 | super.AddBoundingSphere(_PBJtempArray[2]); | ||
3648 | super.AddBoundingSphere(_PBJtempArray[3]); | ||
3649 | } | ||
3650 | } | ||
3651 | } | ||
3652 | } | ||
3653 | } | ||
3654 | namespace Sirikata.Protocol { | ||
3655 | public class CreateObject : PBJ.IMessage { | ||
3656 | protected _PBJ_Internal.CreateObject super; | ||
3657 | public _PBJ_Internal.CreateObject _PBJSuper{ get { return super;} } | ||
3658 | public CreateObject() { | ||
3659 | super=new _PBJ_Internal.CreateObject(); | ||
3660 | } | ||
3661 | public CreateObject(_PBJ_Internal.CreateObject reference) { | ||
3662 | super=reference; | ||
3663 | } | ||
3664 | public static CreateObject defaultInstance= new CreateObject (_PBJ_Internal.CreateObject.DefaultInstance); | ||
3665 | public static CreateObject DefaultInstance{ | ||
3666 | get {return defaultInstance;} | ||
3667 | } | ||
3668 | public static pbd.MessageDescriptor Descriptor { | ||
3669 | get { return _PBJ_Internal.CreateObject.Descriptor; } } | ||
3670 | public static class Types { | ||
3671 | } | ||
3672 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
3673 | return false; | ||
3674 | } | ||
3675 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
3676 | return false; | ||
3677 | } | ||
3678 | public const int ObjectUuidFieldTag=1; | ||
3679 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
3680 | public PBJ.UUID ObjectUuid{ get { | ||
3681 | if (HasObjectUuid) { | ||
3682 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
3683 | } else { | ||
3684 | return PBJ._PBJ.CastUuid(); | ||
3685 | } | ||
3686 | } | ||
3687 | } | ||
3688 | public const int SpacePropertiesFieldTag=2; | ||
3689 | public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} } | ||
3690 | public bool HasSpaceProperties(int index) {return true;} | ||
3691 | public ConnectToSpace SpaceProperties(int index) { | ||
3692 | return new ConnectToSpace(super.GetSpaceProperties(index)); | ||
3693 | } | ||
3694 | public const int MeshFieldTag=3; | ||
3695 | public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} } | ||
3696 | public string Mesh{ get { | ||
3697 | if (HasMesh) { | ||
3698 | return PBJ._PBJ.CastString(super.Mesh); | ||
3699 | } else { | ||
3700 | return PBJ._PBJ.CastString(); | ||
3701 | } | ||
3702 | } | ||
3703 | } | ||
3704 | public const int ScaleFieldTag=4; | ||
3705 | public bool HasScale{ get {return super.ScaleCount>=3;} } | ||
3706 | public PBJ.Vector3f Scale{ get { | ||
3707 | int index=0; | ||
3708 | if (HasScale) { | ||
3709 | return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2)); | ||
3710 | } else { | ||
3711 | return PBJ._PBJ.CastVector3f(); | ||
3712 | } | ||
3713 | } | ||
3714 | } | ||
3715 | public const int WeburlFieldTag=5; | ||
3716 | public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} } | ||
3717 | public string Weburl{ get { | ||
3718 | if (HasWeburl) { | ||
3719 | return PBJ._PBJ.CastString(super.Weburl); | ||
3720 | } else { | ||
3721 | return PBJ._PBJ.CastString(); | ||
3722 | } | ||
3723 | } | ||
3724 | } | ||
3725 | public const int LightInfoFieldTag=6; | ||
3726 | public bool HasLightInfo{ get {return super.HasLightInfo;} } | ||
3727 | public LightInfoProperty LightInfo{ get { | ||
3728 | if (HasLightInfo) { | ||
3729 | return new LightInfoProperty(super.LightInfo); | ||
3730 | } else { | ||
3731 | return new LightInfoProperty(); | ||
3732 | } | ||
3733 | } | ||
3734 | } | ||
3735 | public const int CameraFieldTag=7; | ||
3736 | public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} } | ||
3737 | public bool Camera{ get { | ||
3738 | if (HasCamera) { | ||
3739 | return PBJ._PBJ.CastBool(super.Camera); | ||
3740 | } else { | ||
3741 | return PBJ._PBJ.CastBool(); | ||
3742 | } | ||
3743 | } | ||
3744 | } | ||
3745 | public const int PhysicalFieldTag=8; | ||
3746 | public bool HasPhysical{ get {return super.HasPhysical;} } | ||
3747 | public PhysicalParameters Physical{ get { | ||
3748 | if (HasPhysical) { | ||
3749 | return new PhysicalParameters(super.Physical); | ||
3750 | } else { | ||
3751 | return new PhysicalParameters(); | ||
3752 | } | ||
3753 | } | ||
3754 | } | ||
3755 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
3756 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
3757 | public static Builder CreateBuilder() { return new Builder(); } | ||
3758 | public static Builder CreateBuilder(CreateObject prototype) { | ||
3759 | return (Builder)new Builder().MergeFrom(prototype); | ||
3760 | } | ||
3761 | public static CreateObject ParseFrom(pb::ByteString data) { | ||
3762 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); | ||
3763 | } | ||
3764 | public static CreateObject ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
3765 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); | ||
3766 | } | ||
3767 | public static CreateObject ParseFrom(byte[] data) { | ||
3768 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); | ||
3769 | } | ||
3770 | public static CreateObject ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
3771 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); | ||
3772 | } | ||
3773 | public static CreateObject ParseFrom(global::System.IO.Stream data) { | ||
3774 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); | ||
3775 | } | ||
3776 | public static CreateObject ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
3777 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); | ||
3778 | } | ||
3779 | public static CreateObject ParseFrom(pb::CodedInputStream data) { | ||
3780 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data)); | ||
3781 | } | ||
3782 | public static CreateObject ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
3783 | return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er)); | ||
3784 | } | ||
3785 | protected override bool _HasAllPBJFields{ get { | ||
3786 | return true | ||
3787 | ; | ||
3788 | } } | ||
3789 | public bool IsInitialized { get { | ||
3790 | return super.IsInitialized&&_HasAllPBJFields; | ||
3791 | } } | ||
3792 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
3793 | protected override bool _HasAllPBJFields{ get { | ||
3794 | return true | ||
3795 | ; | ||
3796 | } } | ||
3797 | public bool IsInitialized { get { | ||
3798 | return super.IsInitialized&&_HasAllPBJFields; | ||
3799 | } } | ||
3800 | protected _PBJ_Internal.CreateObject.Builder super; | ||
3801 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
3802 | public _PBJ_Internal.CreateObject.Builder _PBJSuper{ get { return super;} } | ||
3803 | public Builder() {super = new _PBJ_Internal.CreateObject.Builder();} | ||
3804 | public Builder(_PBJ_Internal.CreateObject.Builder other) { | ||
3805 | super=other; | ||
3806 | } | ||
3807 | public Builder Clone() {return new Builder(super.Clone());} | ||
3808 | public Builder MergeFrom(CreateObject prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
3809 | public Builder Clear() {super.Clear();return this;} | ||
3810 | public CreateObject BuildPartial() {return new CreateObject(super.BuildPartial());} | ||
3811 | public CreateObject Build() {if (_HasAllPBJFields) return new CreateObject(super.Build());return null;} | ||
3812 | public pbd::MessageDescriptor DescriptorForType { | ||
3813 | get { return CreateObject.Descriptor; } } | ||
3814 | public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;} | ||
3815 | public const int ObjectUuidFieldTag=1; | ||
3816 | public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} } | ||
3817 | public PBJ.UUID ObjectUuid{ get { | ||
3818 | if (HasObjectUuid) { | ||
3819 | return PBJ._PBJ.CastUuid(super.ObjectUuid); | ||
3820 | } else { | ||
3821 | return PBJ._PBJ.CastUuid(); | ||
3822 | } | ||
3823 | } | ||
3824 | set { | ||
3825 | super.ObjectUuid=(PBJ._PBJ.Construct(value)); | ||
3826 | } | ||
3827 | } | ||
3828 | public Builder ClearSpaceProperties() { super.ClearSpaceProperties();return this;} | ||
3829 | public Builder SetSpaceProperties(int index,ConnectToSpace value) { | ||
3830 | super.SetSpaceProperties(index,value._PBJSuper); | ||
3831 | return this; | ||
3832 | } | ||
3833 | public const int SpacePropertiesFieldTag=2; | ||
3834 | public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} } | ||
3835 | public bool HasSpaceProperties(int index) {return true;} | ||
3836 | public ConnectToSpace SpaceProperties(int index) { | ||
3837 | return new ConnectToSpace(super.GetSpaceProperties(index)); | ||
3838 | } | ||
3839 | public Builder AddSpaceProperties(ConnectToSpace value) { | ||
3840 | super.AddSpaceProperties(value._PBJSuper); | ||
3841 | return this; | ||
3842 | } | ||
3843 | public Builder ClearMesh() { super.ClearMesh();return this;} | ||
3844 | public const int MeshFieldTag=3; | ||
3845 | public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} } | ||
3846 | public string Mesh{ get { | ||
3847 | if (HasMesh) { | ||
3848 | return PBJ._PBJ.CastString(super.Mesh); | ||
3849 | } else { | ||
3850 | return PBJ._PBJ.CastString(); | ||
3851 | } | ||
3852 | } | ||
3853 | set { | ||
3854 | super.Mesh=(PBJ._PBJ.Construct(value)); | ||
3855 | } | ||
3856 | } | ||
3857 | public Builder ClearScale() { super.ClearScale();return this;} | ||
3858 | public const int ScaleFieldTag=4; | ||
3859 | public bool HasScale{ get {return super.ScaleCount>=3;} } | ||
3860 | public PBJ.Vector3f Scale{ get { | ||
3861 | int index=0; | ||
3862 | if (HasScale) { | ||
3863 | return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2)); | ||
3864 | } else { | ||
3865 | return PBJ._PBJ.CastVector3f(); | ||
3866 | } | ||
3867 | } | ||
3868 | set { | ||
3869 | super.ClearScale(); | ||
3870 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
3871 | super.AddScale(_PBJtempArray[0]); | ||
3872 | super.AddScale(_PBJtempArray[1]); | ||
3873 | super.AddScale(_PBJtempArray[2]); | ||
3874 | } | ||
3875 | } | ||
3876 | public Builder ClearWeburl() { super.ClearWeburl();return this;} | ||
3877 | public const int WeburlFieldTag=5; | ||
3878 | public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} } | ||
3879 | public string Weburl{ get { | ||
3880 | if (HasWeburl) { | ||
3881 | return PBJ._PBJ.CastString(super.Weburl); | ||
3882 | } else { | ||
3883 | return PBJ._PBJ.CastString(); | ||
3884 | } | ||
3885 | } | ||
3886 | set { | ||
3887 | super.Weburl=(PBJ._PBJ.Construct(value)); | ||
3888 | } | ||
3889 | } | ||
3890 | public Builder ClearLightInfo() { super.ClearLightInfo();return this;} | ||
3891 | public const int LightInfoFieldTag=6; | ||
3892 | public bool HasLightInfo{ get {return super.HasLightInfo;} } | ||
3893 | public LightInfoProperty LightInfo{ get { | ||
3894 | if (HasLightInfo) { | ||
3895 | return new LightInfoProperty(super.LightInfo); | ||
3896 | } else { | ||
3897 | return new LightInfoProperty(); | ||
3898 | } | ||
3899 | } | ||
3900 | set { | ||
3901 | super.LightInfo=value._PBJSuper; | ||
3902 | } | ||
3903 | } | ||
3904 | public Builder ClearCamera() { super.ClearCamera();return this;} | ||
3905 | public const int CameraFieldTag=7; | ||
3906 | public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} } | ||
3907 | public bool Camera{ get { | ||
3908 | if (HasCamera) { | ||
3909 | return PBJ._PBJ.CastBool(super.Camera); | ||
3910 | } else { | ||
3911 | return PBJ._PBJ.CastBool(); | ||
3912 | } | ||
3913 | } | ||
3914 | set { | ||
3915 | super.Camera=(PBJ._PBJ.Construct(value)); | ||
3916 | } | ||
3917 | } | ||
3918 | public Builder ClearPhysical() { super.ClearPhysical();return this;} | ||
3919 | public const int PhysicalFieldTag=8; | ||
3920 | public bool HasPhysical{ get {return super.HasPhysical;} } | ||
3921 | public PhysicalParameters Physical{ get { | ||
3922 | if (HasPhysical) { | ||
3923 | return new PhysicalParameters(super.Physical); | ||
3924 | } else { | ||
3925 | return new PhysicalParameters(); | ||
3926 | } | ||
3927 | } | ||
3928 | set { | ||
3929 | super.Physical=value._PBJSuper; | ||
3930 | } | ||
3931 | } | ||
3932 | } | ||
3933 | } | ||
3934 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Subscription.cs b/OpenSim/Client/Sirikata/Protocol/Subscription.cs deleted file mode 100644 index 06ac8a2..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Subscription.cs +++ /dev/null | |||
@@ -1,856 +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.Subscription.Protocol._PBJ_Internal { | ||
8 | |||
9 | public static partial class Subscription { | ||
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_Subscription_Protocol__PBJ_Internal_Address__Descriptor; | ||
17 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Subscription.Protocol._PBJ_Internal.Address, global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Builder> internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__FieldAccessorTable; | ||
18 | internal static pbd::MessageDescriptor internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor; | ||
19 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe, global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.Builder> internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__FieldAccessorTable; | ||
20 | internal static pbd::MessageDescriptor internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor; | ||
21 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast, global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.Builder> internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__FieldAccessorTable; | ||
22 | #endregion | ||
23 | #region Descriptor | ||
24 | public static pbd::FileDescriptor Descriptor { | ||
25 | get { return descriptor; } | ||
26 | } | ||
27 | private static pbd::FileDescriptor descriptor; | ||
28 | |||
29 | static Subscription() { | ||
30 | byte[] descriptorData = global::System.Convert.FromBase64String( | ||
31 | "ChJTdWJzY3JpcHRpb24ucHJvdG8SLFNpcmlrYXRhLlN1YnNjcmlwdGlvbi5Q" + | ||
32 | "cm90b2NvbC5fUEJKX0ludGVybmFsIiwKB0FkZHJlc3MSEAoIaG9zdG5hbWUY" + | ||
33 | "ASABKAkSDwoHc2VydmljZRgCIAEoCSKMAQoJU3Vic2NyaWJlElAKEWJyb2Fk" + | ||
34 | "Y2FzdF9hZGRyZXNzGAcgASgLMjUuU2lyaWthdGEuU3Vic2NyaXB0aW9uLlBy" + | ||
35 | "b3RvY29sLl9QQkpfSW50ZXJuYWwuQWRkcmVzcxIWCg5icm9hZGNhc3RfbmFt" + | ||
36 | "ZRgIIAEoDBIVCg11cGRhdGVfcGVyaW9kGAkgASgQIiMKCUJyb2FkY2FzdBIW" + | ||
37 | "Cg5icm9hZGNhc3RfbmFtZRgHIAEoDA=="); | ||
38 | pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | ||
39 | descriptor = root; | ||
40 | internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__Descriptor = Descriptor.MessageTypes[0]; | ||
41 | internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__FieldAccessorTable = | ||
42 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Subscription.Protocol._PBJ_Internal.Address, global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Builder>(internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__Descriptor, | ||
43 | new string[] { "Hostname", "Service", }); | ||
44 | internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor = Descriptor.MessageTypes[1]; | ||
45 | internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__FieldAccessorTable = | ||
46 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe, global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.Builder>(internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor, | ||
47 | new string[] { "BroadcastAddress", "BroadcastName", "UpdatePeriod", }); | ||
48 | internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor = Descriptor.MessageTypes[2]; | ||
49 | internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__FieldAccessorTable = | ||
50 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast, global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.Builder>(internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor, | ||
51 | new string[] { "BroadcastName", }); | ||
52 | return null; | ||
53 | }; | ||
54 | pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | ||
55 | new pbd::FileDescriptor[] { | ||
56 | }, assigner); | ||
57 | } | ||
58 | #endregion | ||
59 | |||
60 | } | ||
61 | #region Messages | ||
62 | public sealed partial class Address : pb::GeneratedMessage<Address, Address.Builder> { | ||
63 | private static readonly Address defaultInstance = new Builder().BuildPartial(); | ||
64 | public static Address DefaultInstance { | ||
65 | get { return defaultInstance; } | ||
66 | } | ||
67 | |||
68 | public override Address DefaultInstanceForType { | ||
69 | get { return defaultInstance; } | ||
70 | } | ||
71 | |||
72 | protected override Address ThisMessage { | ||
73 | get { return this; } | ||
74 | } | ||
75 | |||
76 | public static pbd::MessageDescriptor Descriptor { | ||
77 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__Descriptor; } | ||
78 | } | ||
79 | |||
80 | protected override pb::FieldAccess.FieldAccessorTable<Address, Address.Builder> InternalFieldAccessors { | ||
81 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Address__FieldAccessorTable; } | ||
82 | } | ||
83 | |||
84 | public const int HostnameFieldNumber = 1; | ||
85 | private bool hasHostname; | ||
86 | private string hostname_ = ""; | ||
87 | public bool HasHostname { | ||
88 | get { return hasHostname; } | ||
89 | } | ||
90 | public string Hostname { | ||
91 | get { return hostname_; } | ||
92 | } | ||
93 | |||
94 | public const int ServiceFieldNumber = 2; | ||
95 | private bool hasService; | ||
96 | private string service_ = ""; | ||
97 | public bool HasService { | ||
98 | get { return hasService; } | ||
99 | } | ||
100 | public string Service { | ||
101 | get { return service_; } | ||
102 | } | ||
103 | |||
104 | public override bool IsInitialized { | ||
105 | get { | ||
106 | return true; | ||
107 | } | ||
108 | } | ||
109 | |||
110 | public override void WriteTo(pb::CodedOutputStream output) { | ||
111 | if (HasHostname) { | ||
112 | output.WriteString(1, Hostname); | ||
113 | } | ||
114 | if (HasService) { | ||
115 | output.WriteString(2, Service); | ||
116 | } | ||
117 | UnknownFields.WriteTo(output); | ||
118 | } | ||
119 | |||
120 | private int memoizedSerializedSize = -1; | ||
121 | public override int SerializedSize { | ||
122 | get { | ||
123 | int size = memoizedSerializedSize; | ||
124 | if (size != -1) return size; | ||
125 | |||
126 | size = 0; | ||
127 | if (HasHostname) { | ||
128 | size += pb::CodedOutputStream.ComputeStringSize(1, Hostname); | ||
129 | } | ||
130 | if (HasService) { | ||
131 | size += pb::CodedOutputStream.ComputeStringSize(2, Service); | ||
132 | } | ||
133 | size += UnknownFields.SerializedSize; | ||
134 | memoizedSerializedSize = size; | ||
135 | return size; | ||
136 | } | ||
137 | } | ||
138 | |||
139 | public static Address ParseFrom(pb::ByteString data) { | ||
140 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
141 | } | ||
142 | public static Address ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
143 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
144 | } | ||
145 | public static Address ParseFrom(byte[] data) { | ||
146 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
147 | } | ||
148 | public static Address ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
149 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
150 | } | ||
151 | public static Address ParseFrom(global::System.IO.Stream input) { | ||
152 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
153 | } | ||
154 | public static Address ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
155 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
156 | } | ||
157 | public static Address ParseDelimitedFrom(global::System.IO.Stream input) { | ||
158 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
159 | } | ||
160 | public static Address ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
161 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
162 | } | ||
163 | public static Address ParseFrom(pb::CodedInputStream input) { | ||
164 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
165 | } | ||
166 | public static Address ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
167 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
168 | } | ||
169 | public static Builder CreateBuilder() { return new Builder(); } | ||
170 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
171 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
172 | public static Builder CreateBuilder(Address prototype) { | ||
173 | return (Builder) new Builder().MergeFrom(prototype); | ||
174 | } | ||
175 | |||
176 | public sealed partial class Builder : pb::GeneratedBuilder<Address, Builder> { | ||
177 | protected override Builder ThisBuilder { | ||
178 | get { return this; } | ||
179 | } | ||
180 | public Builder() {} | ||
181 | |||
182 | Address result = new Address(); | ||
183 | |||
184 | protected override Address MessageBeingBuilt { | ||
185 | get { return result; } | ||
186 | } | ||
187 | |||
188 | public override Builder Clear() { | ||
189 | result = new Address(); | ||
190 | return this; | ||
191 | } | ||
192 | |||
193 | public override Builder Clone() { | ||
194 | return new Builder().MergeFrom(result); | ||
195 | } | ||
196 | |||
197 | public override pbd::MessageDescriptor DescriptorForType { | ||
198 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Descriptor; } | ||
199 | } | ||
200 | |||
201 | public override Address DefaultInstanceForType { | ||
202 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance; } | ||
203 | } | ||
204 | |||
205 | public override Address BuildPartial() { | ||
206 | if (result == null) { | ||
207 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
208 | } | ||
209 | Address returnMe = result; | ||
210 | result = null; | ||
211 | return returnMe; | ||
212 | } | ||
213 | |||
214 | public override Builder MergeFrom(pb::IMessage other) { | ||
215 | if (other is Address) { | ||
216 | return MergeFrom((Address) other); | ||
217 | } else { | ||
218 | base.MergeFrom(other); | ||
219 | return this; | ||
220 | } | ||
221 | } | ||
222 | |||
223 | public override Builder MergeFrom(Address other) { | ||
224 | if (other == global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance) return this; | ||
225 | if (other.HasHostname) { | ||
226 | Hostname = other.Hostname; | ||
227 | } | ||
228 | if (other.HasService) { | ||
229 | Service = other.Service; | ||
230 | } | ||
231 | this.MergeUnknownFields(other.UnknownFields); | ||
232 | return this; | ||
233 | } | ||
234 | |||
235 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
236 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
237 | } | ||
238 | |||
239 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
240 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
241 | while (true) { | ||
242 | uint tag = input.ReadTag(); | ||
243 | switch (tag) { | ||
244 | case 0: { | ||
245 | if (unknownFields != null) { | ||
246 | this.UnknownFields = unknownFields.Build(); | ||
247 | } | ||
248 | return this; | ||
249 | } | ||
250 | default: { | ||
251 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
252 | if (unknownFields != null) { | ||
253 | this.UnknownFields = unknownFields.Build(); | ||
254 | } | ||
255 | return this; | ||
256 | } | ||
257 | if (unknownFields == null) { | ||
258 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
259 | } | ||
260 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
261 | break; | ||
262 | } | ||
263 | case 10: { | ||
264 | Hostname = input.ReadString(); | ||
265 | break; | ||
266 | } | ||
267 | case 18: { | ||
268 | Service = input.ReadString(); | ||
269 | break; | ||
270 | } | ||
271 | } | ||
272 | } | ||
273 | } | ||
274 | |||
275 | |||
276 | public bool HasHostname { | ||
277 | get { return result.HasHostname; } | ||
278 | } | ||
279 | public string Hostname { | ||
280 | get { return result.Hostname; } | ||
281 | set { SetHostname(value); } | ||
282 | } | ||
283 | public Builder SetHostname(string value) { | ||
284 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
285 | result.hasHostname = true; | ||
286 | result.hostname_ = value; | ||
287 | return this; | ||
288 | } | ||
289 | public Builder ClearHostname() { | ||
290 | result.hasHostname = false; | ||
291 | result.hostname_ = ""; | ||
292 | return this; | ||
293 | } | ||
294 | |||
295 | public bool HasService { | ||
296 | get { return result.HasService; } | ||
297 | } | ||
298 | public string Service { | ||
299 | get { return result.Service; } | ||
300 | set { SetService(value); } | ||
301 | } | ||
302 | public Builder SetService(string value) { | ||
303 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
304 | result.hasService = true; | ||
305 | result.service_ = value; | ||
306 | return this; | ||
307 | } | ||
308 | public Builder ClearService() { | ||
309 | result.hasService = false; | ||
310 | result.service_ = ""; | ||
311 | return this; | ||
312 | } | ||
313 | } | ||
314 | static Address() { | ||
315 | object.ReferenceEquals(global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.Descriptor, null); | ||
316 | } | ||
317 | } | ||
318 | |||
319 | public sealed partial class Subscribe : pb::GeneratedMessage<Subscribe, Subscribe.Builder> { | ||
320 | private static readonly Subscribe defaultInstance = new Builder().BuildPartial(); | ||
321 | public static Subscribe DefaultInstance { | ||
322 | get { return defaultInstance; } | ||
323 | } | ||
324 | |||
325 | public override Subscribe DefaultInstanceForType { | ||
326 | get { return defaultInstance; } | ||
327 | } | ||
328 | |||
329 | protected override Subscribe ThisMessage { | ||
330 | get { return this; } | ||
331 | } | ||
332 | |||
333 | public static pbd::MessageDescriptor Descriptor { | ||
334 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__Descriptor; } | ||
335 | } | ||
336 | |||
337 | protected override pb::FieldAccess.FieldAccessorTable<Subscribe, Subscribe.Builder> InternalFieldAccessors { | ||
338 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Subscribe__FieldAccessorTable; } | ||
339 | } | ||
340 | |||
341 | public const int BroadcastAddressFieldNumber = 7; | ||
342 | private bool hasBroadcastAddress; | ||
343 | private global::Sirikata.Subscription.Protocol._PBJ_Internal.Address broadcastAddress_ = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance; | ||
344 | public bool HasBroadcastAddress { | ||
345 | get { return hasBroadcastAddress; } | ||
346 | } | ||
347 | public global::Sirikata.Subscription.Protocol._PBJ_Internal.Address BroadcastAddress { | ||
348 | get { return broadcastAddress_; } | ||
349 | } | ||
350 | |||
351 | public const int BroadcastNameFieldNumber = 8; | ||
352 | private bool hasBroadcastName; | ||
353 | private pb::ByteString broadcastName_ = pb::ByteString.Empty; | ||
354 | public bool HasBroadcastName { | ||
355 | get { return hasBroadcastName; } | ||
356 | } | ||
357 | public pb::ByteString BroadcastName { | ||
358 | get { return broadcastName_; } | ||
359 | } | ||
360 | |||
361 | public const int UpdatePeriodFieldNumber = 9; | ||
362 | private bool hasUpdatePeriod; | ||
363 | private long updatePeriod_ = 0; | ||
364 | public bool HasUpdatePeriod { | ||
365 | get { return hasUpdatePeriod; } | ||
366 | } | ||
367 | public long UpdatePeriod { | ||
368 | get { return updatePeriod_; } | ||
369 | } | ||
370 | |||
371 | public override bool IsInitialized { | ||
372 | get { | ||
373 | return true; | ||
374 | } | ||
375 | } | ||
376 | |||
377 | public override void WriteTo(pb::CodedOutputStream output) { | ||
378 | if (HasBroadcastAddress) { | ||
379 | output.WriteMessage(7, BroadcastAddress); | ||
380 | } | ||
381 | if (HasBroadcastName) { | ||
382 | output.WriteBytes(8, BroadcastName); | ||
383 | } | ||
384 | if (HasUpdatePeriod) { | ||
385 | output.WriteSFixed64(9, UpdatePeriod); | ||
386 | } | ||
387 | UnknownFields.WriteTo(output); | ||
388 | } | ||
389 | |||
390 | private int memoizedSerializedSize = -1; | ||
391 | public override int SerializedSize { | ||
392 | get { | ||
393 | int size = memoizedSerializedSize; | ||
394 | if (size != -1) return size; | ||
395 | |||
396 | size = 0; | ||
397 | if (HasBroadcastAddress) { | ||
398 | size += pb::CodedOutputStream.ComputeMessageSize(7, BroadcastAddress); | ||
399 | } | ||
400 | if (HasBroadcastName) { | ||
401 | size += pb::CodedOutputStream.ComputeBytesSize(8, BroadcastName); | ||
402 | } | ||
403 | if (HasUpdatePeriod) { | ||
404 | size += pb::CodedOutputStream.ComputeSFixed64Size(9, UpdatePeriod); | ||
405 | } | ||
406 | size += UnknownFields.SerializedSize; | ||
407 | memoizedSerializedSize = size; | ||
408 | return size; | ||
409 | } | ||
410 | } | ||
411 | |||
412 | public static Subscribe ParseFrom(pb::ByteString data) { | ||
413 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
414 | } | ||
415 | public static Subscribe ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
416 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
417 | } | ||
418 | public static Subscribe ParseFrom(byte[] data) { | ||
419 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
420 | } | ||
421 | public static Subscribe ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
422 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
423 | } | ||
424 | public static Subscribe ParseFrom(global::System.IO.Stream input) { | ||
425 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
426 | } | ||
427 | public static Subscribe ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
428 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
429 | } | ||
430 | public static Subscribe ParseDelimitedFrom(global::System.IO.Stream input) { | ||
431 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
432 | } | ||
433 | public static Subscribe ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
434 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
435 | } | ||
436 | public static Subscribe ParseFrom(pb::CodedInputStream input) { | ||
437 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
438 | } | ||
439 | public static Subscribe ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
440 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
441 | } | ||
442 | public static Builder CreateBuilder() { return new Builder(); } | ||
443 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
444 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
445 | public static Builder CreateBuilder(Subscribe prototype) { | ||
446 | return (Builder) new Builder().MergeFrom(prototype); | ||
447 | } | ||
448 | |||
449 | public sealed partial class Builder : pb::GeneratedBuilder<Subscribe, Builder> { | ||
450 | protected override Builder ThisBuilder { | ||
451 | get { return this; } | ||
452 | } | ||
453 | public Builder() {} | ||
454 | |||
455 | Subscribe result = new Subscribe(); | ||
456 | |||
457 | protected override Subscribe MessageBeingBuilt { | ||
458 | get { return result; } | ||
459 | } | ||
460 | |||
461 | public override Builder Clear() { | ||
462 | result = new Subscribe(); | ||
463 | return this; | ||
464 | } | ||
465 | |||
466 | public override Builder Clone() { | ||
467 | return new Builder().MergeFrom(result); | ||
468 | } | ||
469 | |||
470 | public override pbd::MessageDescriptor DescriptorForType { | ||
471 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.Descriptor; } | ||
472 | } | ||
473 | |||
474 | public override Subscribe DefaultInstanceForType { | ||
475 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.DefaultInstance; } | ||
476 | } | ||
477 | |||
478 | public override Subscribe BuildPartial() { | ||
479 | if (result == null) { | ||
480 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
481 | } | ||
482 | Subscribe returnMe = result; | ||
483 | result = null; | ||
484 | return returnMe; | ||
485 | } | ||
486 | |||
487 | public override Builder MergeFrom(pb::IMessage other) { | ||
488 | if (other is Subscribe) { | ||
489 | return MergeFrom((Subscribe) other); | ||
490 | } else { | ||
491 | base.MergeFrom(other); | ||
492 | return this; | ||
493 | } | ||
494 | } | ||
495 | |||
496 | public override Builder MergeFrom(Subscribe other) { | ||
497 | if (other == global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscribe.DefaultInstance) return this; | ||
498 | if (other.HasBroadcastAddress) { | ||
499 | MergeBroadcastAddress(other.BroadcastAddress); | ||
500 | } | ||
501 | if (other.HasBroadcastName) { | ||
502 | BroadcastName = other.BroadcastName; | ||
503 | } | ||
504 | if (other.HasUpdatePeriod) { | ||
505 | UpdatePeriod = other.UpdatePeriod; | ||
506 | } | ||
507 | this.MergeUnknownFields(other.UnknownFields); | ||
508 | return this; | ||
509 | } | ||
510 | |||
511 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
512 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
513 | } | ||
514 | |||
515 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
516 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
517 | while (true) { | ||
518 | uint tag = input.ReadTag(); | ||
519 | switch (tag) { | ||
520 | case 0: { | ||
521 | if (unknownFields != null) { | ||
522 | this.UnknownFields = unknownFields.Build(); | ||
523 | } | ||
524 | return this; | ||
525 | } | ||
526 | default: { | ||
527 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
528 | if (unknownFields != null) { | ||
529 | this.UnknownFields = unknownFields.Build(); | ||
530 | } | ||
531 | return this; | ||
532 | } | ||
533 | if (unknownFields == null) { | ||
534 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
535 | } | ||
536 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
537 | break; | ||
538 | } | ||
539 | case 58: { | ||
540 | global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Builder subBuilder = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.CreateBuilder(); | ||
541 | if (HasBroadcastAddress) { | ||
542 | subBuilder.MergeFrom(BroadcastAddress); | ||
543 | } | ||
544 | input.ReadMessage(subBuilder, extensionRegistry); | ||
545 | BroadcastAddress = subBuilder.BuildPartial(); | ||
546 | break; | ||
547 | } | ||
548 | case 66: { | ||
549 | BroadcastName = input.ReadBytes(); | ||
550 | break; | ||
551 | } | ||
552 | case 73: { | ||
553 | UpdatePeriod = input.ReadSFixed64(); | ||
554 | break; | ||
555 | } | ||
556 | } | ||
557 | } | ||
558 | } | ||
559 | |||
560 | |||
561 | public bool HasBroadcastAddress { | ||
562 | get { return result.HasBroadcastAddress; } | ||
563 | } | ||
564 | public global::Sirikata.Subscription.Protocol._PBJ_Internal.Address BroadcastAddress { | ||
565 | get { return result.BroadcastAddress; } | ||
566 | set { SetBroadcastAddress(value); } | ||
567 | } | ||
568 | public Builder SetBroadcastAddress(global::Sirikata.Subscription.Protocol._PBJ_Internal.Address value) { | ||
569 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
570 | result.hasBroadcastAddress = true; | ||
571 | result.broadcastAddress_ = value; | ||
572 | return this; | ||
573 | } | ||
574 | public Builder SetBroadcastAddress(global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.Builder builderForValue) { | ||
575 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
576 | result.hasBroadcastAddress = true; | ||
577 | result.broadcastAddress_ = builderForValue.Build(); | ||
578 | return this; | ||
579 | } | ||
580 | public Builder MergeBroadcastAddress(global::Sirikata.Subscription.Protocol._PBJ_Internal.Address value) { | ||
581 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
582 | if (result.HasBroadcastAddress && | ||
583 | result.broadcastAddress_ != global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance) { | ||
584 | result.broadcastAddress_ = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.CreateBuilder(result.broadcastAddress_).MergeFrom(value).BuildPartial(); | ||
585 | } else { | ||
586 | result.broadcastAddress_ = value; | ||
587 | } | ||
588 | result.hasBroadcastAddress = true; | ||
589 | return this; | ||
590 | } | ||
591 | public Builder ClearBroadcastAddress() { | ||
592 | result.hasBroadcastAddress = false; | ||
593 | result.broadcastAddress_ = global::Sirikata.Subscription.Protocol._PBJ_Internal.Address.DefaultInstance; | ||
594 | return this; | ||
595 | } | ||
596 | |||
597 | public bool HasBroadcastName { | ||
598 | get { return result.HasBroadcastName; } | ||
599 | } | ||
600 | public pb::ByteString BroadcastName { | ||
601 | get { return result.BroadcastName; } | ||
602 | set { SetBroadcastName(value); } | ||
603 | } | ||
604 | public Builder SetBroadcastName(pb::ByteString value) { | ||
605 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
606 | result.hasBroadcastName = true; | ||
607 | result.broadcastName_ = value; | ||
608 | return this; | ||
609 | } | ||
610 | public Builder ClearBroadcastName() { | ||
611 | result.hasBroadcastName = false; | ||
612 | result.broadcastName_ = pb::ByteString.Empty; | ||
613 | return this; | ||
614 | } | ||
615 | |||
616 | public bool HasUpdatePeriod { | ||
617 | get { return result.HasUpdatePeriod; } | ||
618 | } | ||
619 | public long UpdatePeriod { | ||
620 | get { return result.UpdatePeriod; } | ||
621 | set { SetUpdatePeriod(value); } | ||
622 | } | ||
623 | public Builder SetUpdatePeriod(long value) { | ||
624 | result.hasUpdatePeriod = true; | ||
625 | result.updatePeriod_ = value; | ||
626 | return this; | ||
627 | } | ||
628 | public Builder ClearUpdatePeriod() { | ||
629 | result.hasUpdatePeriod = false; | ||
630 | result.updatePeriod_ = 0; | ||
631 | return this; | ||
632 | } | ||
633 | } | ||
634 | static Subscribe() { | ||
635 | object.ReferenceEquals(global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.Descriptor, null); | ||
636 | } | ||
637 | } | ||
638 | |||
639 | public sealed partial class Broadcast : pb::GeneratedMessage<Broadcast, Broadcast.Builder> { | ||
640 | private static readonly Broadcast defaultInstance = new Builder().BuildPartial(); | ||
641 | public static Broadcast DefaultInstance { | ||
642 | get { return defaultInstance; } | ||
643 | } | ||
644 | |||
645 | public override Broadcast DefaultInstanceForType { | ||
646 | get { return defaultInstance; } | ||
647 | } | ||
648 | |||
649 | protected override Broadcast ThisMessage { | ||
650 | get { return this; } | ||
651 | } | ||
652 | |||
653 | public static pbd::MessageDescriptor Descriptor { | ||
654 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__Descriptor; } | ||
655 | } | ||
656 | |||
657 | protected override pb::FieldAccess.FieldAccessorTable<Broadcast, Broadcast.Builder> InternalFieldAccessors { | ||
658 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.internal__static_Sirikata_Subscription_Protocol__PBJ_Internal_Broadcast__FieldAccessorTable; } | ||
659 | } | ||
660 | |||
661 | public const int BroadcastNameFieldNumber = 7; | ||
662 | private bool hasBroadcastName; | ||
663 | private pb::ByteString broadcastName_ = pb::ByteString.Empty; | ||
664 | public bool HasBroadcastName { | ||
665 | get { return hasBroadcastName; } | ||
666 | } | ||
667 | public pb::ByteString BroadcastName { | ||
668 | get { return broadcastName_; } | ||
669 | } | ||
670 | |||
671 | public override bool IsInitialized { | ||
672 | get { | ||
673 | return true; | ||
674 | } | ||
675 | } | ||
676 | |||
677 | public override void WriteTo(pb::CodedOutputStream output) { | ||
678 | if (HasBroadcastName) { | ||
679 | output.WriteBytes(7, BroadcastName); | ||
680 | } | ||
681 | UnknownFields.WriteTo(output); | ||
682 | } | ||
683 | |||
684 | private int memoizedSerializedSize = -1; | ||
685 | public override int SerializedSize { | ||
686 | get { | ||
687 | int size = memoizedSerializedSize; | ||
688 | if (size != -1) return size; | ||
689 | |||
690 | size = 0; | ||
691 | if (HasBroadcastName) { | ||
692 | size += pb::CodedOutputStream.ComputeBytesSize(7, BroadcastName); | ||
693 | } | ||
694 | size += UnknownFields.SerializedSize; | ||
695 | memoizedSerializedSize = size; | ||
696 | return size; | ||
697 | } | ||
698 | } | ||
699 | |||
700 | public static Broadcast ParseFrom(pb::ByteString data) { | ||
701 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
702 | } | ||
703 | public static Broadcast ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
704 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
705 | } | ||
706 | public static Broadcast ParseFrom(byte[] data) { | ||
707 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
708 | } | ||
709 | public static Broadcast ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
710 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
711 | } | ||
712 | public static Broadcast ParseFrom(global::System.IO.Stream input) { | ||
713 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
714 | } | ||
715 | public static Broadcast ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
716 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
717 | } | ||
718 | public static Broadcast ParseDelimitedFrom(global::System.IO.Stream input) { | ||
719 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
720 | } | ||
721 | public static Broadcast ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
722 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
723 | } | ||
724 | public static Broadcast ParseFrom(pb::CodedInputStream input) { | ||
725 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
726 | } | ||
727 | public static Broadcast ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
728 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
729 | } | ||
730 | public static Builder CreateBuilder() { return new Builder(); } | ||
731 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
732 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
733 | public static Builder CreateBuilder(Broadcast prototype) { | ||
734 | return (Builder) new Builder().MergeFrom(prototype); | ||
735 | } | ||
736 | |||
737 | public sealed partial class Builder : pb::GeneratedBuilder<Broadcast, Builder> { | ||
738 | protected override Builder ThisBuilder { | ||
739 | get { return this; } | ||
740 | } | ||
741 | public Builder() {} | ||
742 | |||
743 | Broadcast result = new Broadcast(); | ||
744 | |||
745 | protected override Broadcast MessageBeingBuilt { | ||
746 | get { return result; } | ||
747 | } | ||
748 | |||
749 | public override Builder Clear() { | ||
750 | result = new Broadcast(); | ||
751 | return this; | ||
752 | } | ||
753 | |||
754 | public override Builder Clone() { | ||
755 | return new Builder().MergeFrom(result); | ||
756 | } | ||
757 | |||
758 | public override pbd::MessageDescriptor DescriptorForType { | ||
759 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.Descriptor; } | ||
760 | } | ||
761 | |||
762 | public override Broadcast DefaultInstanceForType { | ||
763 | get { return global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.DefaultInstance; } | ||
764 | } | ||
765 | |||
766 | public override Broadcast BuildPartial() { | ||
767 | if (result == null) { | ||
768 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
769 | } | ||
770 | Broadcast returnMe = result; | ||
771 | result = null; | ||
772 | return returnMe; | ||
773 | } | ||
774 | |||
775 | public override Builder MergeFrom(pb::IMessage other) { | ||
776 | if (other is Broadcast) { | ||
777 | return MergeFrom((Broadcast) other); | ||
778 | } else { | ||
779 | base.MergeFrom(other); | ||
780 | return this; | ||
781 | } | ||
782 | } | ||
783 | |||
784 | public override Builder MergeFrom(Broadcast other) { | ||
785 | if (other == global::Sirikata.Subscription.Protocol._PBJ_Internal.Broadcast.DefaultInstance) return this; | ||
786 | if (other.HasBroadcastName) { | ||
787 | BroadcastName = other.BroadcastName; | ||
788 | } | ||
789 | this.MergeUnknownFields(other.UnknownFields); | ||
790 | return this; | ||
791 | } | ||
792 | |||
793 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
794 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
795 | } | ||
796 | |||
797 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
798 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
799 | while (true) { | ||
800 | uint tag = input.ReadTag(); | ||
801 | switch (tag) { | ||
802 | case 0: { | ||
803 | if (unknownFields != null) { | ||
804 | this.UnknownFields = unknownFields.Build(); | ||
805 | } | ||
806 | return this; | ||
807 | } | ||
808 | default: { | ||
809 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
810 | if (unknownFields != null) { | ||
811 | this.UnknownFields = unknownFields.Build(); | ||
812 | } | ||
813 | return this; | ||
814 | } | ||
815 | if (unknownFields == null) { | ||
816 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
817 | } | ||
818 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
819 | break; | ||
820 | } | ||
821 | case 58: { | ||
822 | BroadcastName = input.ReadBytes(); | ||
823 | break; | ||
824 | } | ||
825 | } | ||
826 | } | ||
827 | } | ||
828 | |||
829 | |||
830 | public bool HasBroadcastName { | ||
831 | get { return result.HasBroadcastName; } | ||
832 | } | ||
833 | public pb::ByteString BroadcastName { | ||
834 | get { return result.BroadcastName; } | ||
835 | set { SetBroadcastName(value); } | ||
836 | } | ||
837 | public Builder SetBroadcastName(pb::ByteString value) { | ||
838 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
839 | result.hasBroadcastName = true; | ||
840 | result.broadcastName_ = value; | ||
841 | return this; | ||
842 | } | ||
843 | public Builder ClearBroadcastName() { | ||
844 | result.hasBroadcastName = false; | ||
845 | result.broadcastName_ = pb::ByteString.Empty; | ||
846 | return this; | ||
847 | } | ||
848 | } | ||
849 | static Broadcast() { | ||
850 | object.ReferenceEquals(global::Sirikata.Subscription.Protocol._PBJ_Internal.Subscription.Descriptor, null); | ||
851 | } | ||
852 | } | ||
853 | |||
854 | #endregion | ||
855 | |||
856 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs deleted file mode 100644 index c8c2fbf..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs +++ /dev/null | |||
@@ -1,431 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace Sirikata.Subscription.Protocol { | ||
31 | public class Address : PBJ.IMessage { | ||
32 | protected _PBJ_Internal.Address super; | ||
33 | public _PBJ_Internal.Address _PBJSuper{ get { return super;} } | ||
34 | public Address() { | ||
35 | super=new _PBJ_Internal.Address(); | ||
36 | } | ||
37 | public Address(_PBJ_Internal.Address reference) { | ||
38 | super=reference; | ||
39 | } | ||
40 | public static Address defaultInstance= new Address (_PBJ_Internal.Address.DefaultInstance); | ||
41 | public static Address DefaultInstance{ | ||
42 | get {return defaultInstance;} | ||
43 | } | ||
44 | public static pbd.MessageDescriptor Descriptor { | ||
45 | get { return _PBJ_Internal.Address.Descriptor; } } | ||
46 | public static class Types { | ||
47 | } | ||
48 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
49 | return false; | ||
50 | } | ||
51 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
52 | return false; | ||
53 | } | ||
54 | public const int HostnameFieldTag=1; | ||
55 | public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} } | ||
56 | public string Hostname{ get { | ||
57 | if (HasHostname) { | ||
58 | return PBJ._PBJ.CastString(super.Hostname); | ||
59 | } else { | ||
60 | return PBJ._PBJ.CastString(); | ||
61 | } | ||
62 | } | ||
63 | } | ||
64 | public const int ServiceFieldTag=2; | ||
65 | public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} } | ||
66 | public string Service{ get { | ||
67 | if (HasService) { | ||
68 | return PBJ._PBJ.CastString(super.Service); | ||
69 | } else { | ||
70 | return PBJ._PBJ.CastString(); | ||
71 | } | ||
72 | } | ||
73 | } | ||
74 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
75 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
76 | public static Builder CreateBuilder() { return new Builder(); } | ||
77 | public static Builder CreateBuilder(Address prototype) { | ||
78 | return (Builder)new Builder().MergeFrom(prototype); | ||
79 | } | ||
80 | public static Address ParseFrom(pb::ByteString data) { | ||
81 | return new Address(_PBJ_Internal.Address.ParseFrom(data)); | ||
82 | } | ||
83 | public static Address ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
84 | return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); | ||
85 | } | ||
86 | public static Address ParseFrom(byte[] data) { | ||
87 | return new Address(_PBJ_Internal.Address.ParseFrom(data)); | ||
88 | } | ||
89 | public static Address ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
90 | return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); | ||
91 | } | ||
92 | public static Address ParseFrom(global::System.IO.Stream data) { | ||
93 | return new Address(_PBJ_Internal.Address.ParseFrom(data)); | ||
94 | } | ||
95 | public static Address ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
96 | return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); | ||
97 | } | ||
98 | public static Address ParseFrom(pb::CodedInputStream data) { | ||
99 | return new Address(_PBJ_Internal.Address.ParseFrom(data)); | ||
100 | } | ||
101 | public static Address ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
102 | return new Address(_PBJ_Internal.Address.ParseFrom(data,er)); | ||
103 | } | ||
104 | protected override bool _HasAllPBJFields{ get { | ||
105 | return true | ||
106 | ; | ||
107 | } } | ||
108 | public bool IsInitialized { get { | ||
109 | return super.IsInitialized&&_HasAllPBJFields; | ||
110 | } } | ||
111 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
112 | protected override bool _HasAllPBJFields{ get { | ||
113 | return true | ||
114 | ; | ||
115 | } } | ||
116 | public bool IsInitialized { get { | ||
117 | return super.IsInitialized&&_HasAllPBJFields; | ||
118 | } } | ||
119 | protected _PBJ_Internal.Address.Builder super; | ||
120 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
121 | public _PBJ_Internal.Address.Builder _PBJSuper{ get { return super;} } | ||
122 | public Builder() {super = new _PBJ_Internal.Address.Builder();} | ||
123 | public Builder(_PBJ_Internal.Address.Builder other) { | ||
124 | super=other; | ||
125 | } | ||
126 | public Builder Clone() {return new Builder(super.Clone());} | ||
127 | public Builder MergeFrom(Address prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
128 | public Builder Clear() {super.Clear();return this;} | ||
129 | public Address BuildPartial() {return new Address(super.BuildPartial());} | ||
130 | public Address Build() {if (_HasAllPBJFields) return new Address(super.Build());return null;} | ||
131 | public pbd::MessageDescriptor DescriptorForType { | ||
132 | get { return Address.Descriptor; } } | ||
133 | public Builder ClearHostname() { super.ClearHostname();return this;} | ||
134 | public const int HostnameFieldTag=1; | ||
135 | public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} } | ||
136 | public string Hostname{ get { | ||
137 | if (HasHostname) { | ||
138 | return PBJ._PBJ.CastString(super.Hostname); | ||
139 | } else { | ||
140 | return PBJ._PBJ.CastString(); | ||
141 | } | ||
142 | } | ||
143 | set { | ||
144 | super.Hostname=(PBJ._PBJ.Construct(value)); | ||
145 | } | ||
146 | } | ||
147 | public Builder ClearService() { super.ClearService();return this;} | ||
148 | public const int ServiceFieldTag=2; | ||
149 | public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} } | ||
150 | public string Service{ get { | ||
151 | if (HasService) { | ||
152 | return PBJ._PBJ.CastString(super.Service); | ||
153 | } else { | ||
154 | return PBJ._PBJ.CastString(); | ||
155 | } | ||
156 | } | ||
157 | set { | ||
158 | super.Service=(PBJ._PBJ.Construct(value)); | ||
159 | } | ||
160 | } | ||
161 | } | ||
162 | } | ||
163 | } | ||
164 | namespace Sirikata.Subscription.Protocol { | ||
165 | public class Subscribe : PBJ.IMessage { | ||
166 | protected _PBJ_Internal.Subscribe super; | ||
167 | public _PBJ_Internal.Subscribe _PBJSuper{ get { return super;} } | ||
168 | public Subscribe() { | ||
169 | super=new _PBJ_Internal.Subscribe(); | ||
170 | } | ||
171 | public Subscribe(_PBJ_Internal.Subscribe reference) { | ||
172 | super=reference; | ||
173 | } | ||
174 | public static Subscribe defaultInstance= new Subscribe (_PBJ_Internal.Subscribe.DefaultInstance); | ||
175 | public static Subscribe DefaultInstance{ | ||
176 | get {return defaultInstance;} | ||
177 | } | ||
178 | public static pbd.MessageDescriptor Descriptor { | ||
179 | get { return _PBJ_Internal.Subscribe.Descriptor; } } | ||
180 | public static class Types { | ||
181 | } | ||
182 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
183 | return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
184 | } | ||
185 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
186 | return false; | ||
187 | } | ||
188 | public const int BroadcastAddressFieldTag=7; | ||
189 | public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} } | ||
190 | public Address BroadcastAddress{ get { | ||
191 | if (HasBroadcastAddress) { | ||
192 | return new Address(super.BroadcastAddress); | ||
193 | } else { | ||
194 | return new Address(); | ||
195 | } | ||
196 | } | ||
197 | } | ||
198 | public const int BroadcastNameFieldTag=8; | ||
199 | public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } | ||
200 | public PBJ.UUID BroadcastName{ get { | ||
201 | if (HasBroadcastName) { | ||
202 | return PBJ._PBJ.CastUuid(super.BroadcastName); | ||
203 | } else { | ||
204 | return PBJ._PBJ.CastUuid(); | ||
205 | } | ||
206 | } | ||
207 | } | ||
208 | public const int UpdatePeriodFieldTag=9; | ||
209 | public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} } | ||
210 | public PBJ.Duration UpdatePeriod{ get { | ||
211 | if (HasUpdatePeriod) { | ||
212 | return PBJ._PBJ.CastDuration(super.UpdatePeriod); | ||
213 | } else { | ||
214 | return PBJ._PBJ.CastDuration(); | ||
215 | } | ||
216 | } | ||
217 | } | ||
218 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
219 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
220 | public static Builder CreateBuilder() { return new Builder(); } | ||
221 | public static Builder CreateBuilder(Subscribe prototype) { | ||
222 | return (Builder)new Builder().MergeFrom(prototype); | ||
223 | } | ||
224 | public static Subscribe ParseFrom(pb::ByteString data) { | ||
225 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); | ||
226 | } | ||
227 | public static Subscribe ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
228 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); | ||
229 | } | ||
230 | public static Subscribe ParseFrom(byte[] data) { | ||
231 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); | ||
232 | } | ||
233 | public static Subscribe ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
234 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); | ||
235 | } | ||
236 | public static Subscribe ParseFrom(global::System.IO.Stream data) { | ||
237 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); | ||
238 | } | ||
239 | public static Subscribe ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
240 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); | ||
241 | } | ||
242 | public static Subscribe ParseFrom(pb::CodedInputStream data) { | ||
243 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data)); | ||
244 | } | ||
245 | public static Subscribe ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
246 | return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er)); | ||
247 | } | ||
248 | protected override bool _HasAllPBJFields{ get { | ||
249 | return true | ||
250 | ; | ||
251 | } } | ||
252 | public bool IsInitialized { get { | ||
253 | return super.IsInitialized&&_HasAllPBJFields; | ||
254 | } } | ||
255 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
256 | protected override bool _HasAllPBJFields{ get { | ||
257 | return true | ||
258 | ; | ||
259 | } } | ||
260 | public bool IsInitialized { get { | ||
261 | return super.IsInitialized&&_HasAllPBJFields; | ||
262 | } } | ||
263 | protected _PBJ_Internal.Subscribe.Builder super; | ||
264 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
265 | public _PBJ_Internal.Subscribe.Builder _PBJSuper{ get { return super;} } | ||
266 | public Builder() {super = new _PBJ_Internal.Subscribe.Builder();} | ||
267 | public Builder(_PBJ_Internal.Subscribe.Builder other) { | ||
268 | super=other; | ||
269 | } | ||
270 | public Builder Clone() {return new Builder(super.Clone());} | ||
271 | public Builder MergeFrom(Subscribe prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
272 | public Builder Clear() {super.Clear();return this;} | ||
273 | public Subscribe BuildPartial() {return new Subscribe(super.BuildPartial());} | ||
274 | public Subscribe Build() {if (_HasAllPBJFields) return new Subscribe(super.Build());return null;} | ||
275 | public pbd::MessageDescriptor DescriptorForType { | ||
276 | get { return Subscribe.Descriptor; } } | ||
277 | public Builder ClearBroadcastAddress() { super.ClearBroadcastAddress();return this;} | ||
278 | public const int BroadcastAddressFieldTag=7; | ||
279 | public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} } | ||
280 | public Address BroadcastAddress{ get { | ||
281 | if (HasBroadcastAddress) { | ||
282 | return new Address(super.BroadcastAddress); | ||
283 | } else { | ||
284 | return new Address(); | ||
285 | } | ||
286 | } | ||
287 | set { | ||
288 | super.BroadcastAddress=value._PBJSuper; | ||
289 | } | ||
290 | } | ||
291 | public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;} | ||
292 | public const int BroadcastNameFieldTag=8; | ||
293 | public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } | ||
294 | public PBJ.UUID BroadcastName{ get { | ||
295 | if (HasBroadcastName) { | ||
296 | return PBJ._PBJ.CastUuid(super.BroadcastName); | ||
297 | } else { | ||
298 | return PBJ._PBJ.CastUuid(); | ||
299 | } | ||
300 | } | ||
301 | set { | ||
302 | super.BroadcastName=(PBJ._PBJ.Construct(value)); | ||
303 | } | ||
304 | } | ||
305 | public Builder ClearUpdatePeriod() { super.ClearUpdatePeriod();return this;} | ||
306 | public const int UpdatePeriodFieldTag=9; | ||
307 | public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} } | ||
308 | public PBJ.Duration UpdatePeriod{ get { | ||
309 | if (HasUpdatePeriod) { | ||
310 | return PBJ._PBJ.CastDuration(super.UpdatePeriod); | ||
311 | } else { | ||
312 | return PBJ._PBJ.CastDuration(); | ||
313 | } | ||
314 | } | ||
315 | set { | ||
316 | super.UpdatePeriod=(PBJ._PBJ.Construct(value)); | ||
317 | } | ||
318 | } | ||
319 | } | ||
320 | } | ||
321 | } | ||
322 | namespace Sirikata.Subscription.Protocol { | ||
323 | public class Broadcast : PBJ.IMessage { | ||
324 | protected _PBJ_Internal.Broadcast super; | ||
325 | public _PBJ_Internal.Broadcast _PBJSuper{ get { return super;} } | ||
326 | public Broadcast() { | ||
327 | super=new _PBJ_Internal.Broadcast(); | ||
328 | } | ||
329 | public Broadcast(_PBJ_Internal.Broadcast reference) { | ||
330 | super=reference; | ||
331 | } | ||
332 | public static Broadcast defaultInstance= new Broadcast (_PBJ_Internal.Broadcast.DefaultInstance); | ||
333 | public static Broadcast DefaultInstance{ | ||
334 | get {return defaultInstance;} | ||
335 | } | ||
336 | public static pbd.MessageDescriptor Descriptor { | ||
337 | get { return _PBJ_Internal.Broadcast.Descriptor; } } | ||
338 | public static class Types { | ||
339 | } | ||
340 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
341 | return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
342 | } | ||
343 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
344 | return false; | ||
345 | } | ||
346 | public const int BroadcastNameFieldTag=7; | ||
347 | public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } | ||
348 | public PBJ.UUID BroadcastName{ get { | ||
349 | if (HasBroadcastName) { | ||
350 | return PBJ._PBJ.CastUuid(super.BroadcastName); | ||
351 | } else { | ||
352 | return PBJ._PBJ.CastUuid(); | ||
353 | } | ||
354 | } | ||
355 | } | ||
356 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
357 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
358 | public static Builder CreateBuilder() { return new Builder(); } | ||
359 | public static Builder CreateBuilder(Broadcast prototype) { | ||
360 | return (Builder)new Builder().MergeFrom(prototype); | ||
361 | } | ||
362 | public static Broadcast ParseFrom(pb::ByteString data) { | ||
363 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); | ||
364 | } | ||
365 | public static Broadcast ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
366 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); | ||
367 | } | ||
368 | public static Broadcast ParseFrom(byte[] data) { | ||
369 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); | ||
370 | } | ||
371 | public static Broadcast ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
372 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); | ||
373 | } | ||
374 | public static Broadcast ParseFrom(global::System.IO.Stream data) { | ||
375 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); | ||
376 | } | ||
377 | public static Broadcast ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
378 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); | ||
379 | } | ||
380 | public static Broadcast ParseFrom(pb::CodedInputStream data) { | ||
381 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data)); | ||
382 | } | ||
383 | public static Broadcast ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
384 | return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er)); | ||
385 | } | ||
386 | protected override bool _HasAllPBJFields{ get { | ||
387 | return true | ||
388 | ; | ||
389 | } } | ||
390 | public bool IsInitialized { get { | ||
391 | return super.IsInitialized&&_HasAllPBJFields; | ||
392 | } } | ||
393 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
394 | protected override bool _HasAllPBJFields{ get { | ||
395 | return true | ||
396 | ; | ||
397 | } } | ||
398 | public bool IsInitialized { get { | ||
399 | return super.IsInitialized&&_HasAllPBJFields; | ||
400 | } } | ||
401 | protected _PBJ_Internal.Broadcast.Builder super; | ||
402 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
403 | public _PBJ_Internal.Broadcast.Builder _PBJSuper{ get { return super;} } | ||
404 | public Builder() {super = new _PBJ_Internal.Broadcast.Builder();} | ||
405 | public Builder(_PBJ_Internal.Broadcast.Builder other) { | ||
406 | super=other; | ||
407 | } | ||
408 | public Builder Clone() {return new Builder(super.Clone());} | ||
409 | public Builder MergeFrom(Broadcast prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
410 | public Builder Clear() {super.Clear();return this;} | ||
411 | public Broadcast BuildPartial() {return new Broadcast(super.BuildPartial());} | ||
412 | public Broadcast Build() {if (_HasAllPBJFields) return new Broadcast(super.Build());return null;} | ||
413 | public pbd::MessageDescriptor DescriptorForType { | ||
414 | get { return Broadcast.Descriptor; } } | ||
415 | public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;} | ||
416 | public const int BroadcastNameFieldTag=7; | ||
417 | public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} } | ||
418 | public PBJ.UUID BroadcastName{ get { | ||
419 | if (HasBroadcastName) { | ||
420 | return PBJ._PBJ.CastUuid(super.BroadcastName); | ||
421 | } else { | ||
422 | return PBJ._PBJ.CastUuid(); | ||
423 | } | ||
424 | } | ||
425 | set { | ||
426 | super.BroadcastName=(PBJ._PBJ.Construct(value)); | ||
427 | } | ||
428 | } | ||
429 | } | ||
430 | } | ||
431 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Test.cs b/OpenSim/Client/Sirikata/Protocol/Test.cs deleted file mode 100644 index 0e1372a..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Test.cs +++ /dev/null | |||
@@ -1,3773 +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.PB._PBJ_Internal { | ||
8 | |||
9 | public static partial class Test { | ||
10 | |||
11 | #region Extension registration | ||
12 | public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { | ||
13 | registry.Add(global::Sirikata.PB._PBJ_Internal.Test.Extensionbbox); | ||
14 | registry.Add(global::Sirikata.PB._PBJ_Internal.Test.Extensionvector); | ||
15 | } | ||
16 | #endregion | ||
17 | #region Extensions | ||
18 | public const int ExtensionbboxFieldNumber = 100; | ||
19 | public static pb::GeneratedExtensionBase<scg::IList<float>> Extensionbbox; | ||
20 | public const int ExtensionvectorFieldNumber = 101; | ||
21 | public static pb::GeneratedExtensionBase<scg::IList<float>> Extensionvector; | ||
22 | #endregion | ||
23 | |||
24 | #region Static variables | ||
25 | internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor; | ||
26 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable; | ||
27 | internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor; | ||
28 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable; | ||
29 | internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor; | ||
30 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable; | ||
31 | internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor; | ||
32 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable; | ||
33 | #endregion | ||
34 | #region Descriptor | ||
35 | public static pbd::FileDescriptor Descriptor { | ||
36 | get { return descriptor; } | ||
37 | } | ||
38 | private static pbd::FileDescriptor descriptor; | ||
39 | |||
40 | static Test() { | ||
41 | byte[] descriptorData = global::System.Convert.FromBase64String( | ||
42 | "CgpUZXN0LnByb3RvEhlTaXJpa2F0YS5QQi5fUEJKX0ludGVybmFsIuwCCg9F" + | ||
43 | "eHRlcm5hbE1lc3NhZ2USFQoHaXNfdHJ1ZRgoIAEoCDoEdHJ1ZRIPCgN2MmYY" + | ||
44 | "AiADKAJCAhABEkYKB3N1Yl9tZXMYHiABKAsyNS5TaXJpa2F0YS5QQi5fUEJK" + | ||
45 | "X0ludGVybmFsLkV4dGVybmFsTWVzc2FnZS5TdWJNZXNzYWdlEkkKCnN1Ym1l" + | ||
46 | "c3NlcnMYHyADKAsyNS5TaXJpa2F0YS5QQi5fUEJKX0ludGVybmFsLkV4dGVy" + | ||
47 | "bmFsTWVzc2FnZS5TdWJNZXNzYWdlEgsKA3NoYRggIAEoDBIMCgRzaGFzGCEg" + | ||
48 | "AygMEg8KA3YzZhgEIAMoAkICEAESEAoEdjNmZhgFIAMoAkICEAEaYAoKU3Vi" + | ||
49 | "TWVzc2FnZRIPCgdzdWJ1dWlkGAEgASgMEhUKCXN1YnZlY3RvchgCIAMoAUIC" + | ||
50 | "EAESEwoLc3ViZHVyYXRpb24YAyABKBASFQoJc3Vibm9ybWFsGAQgAygCQgIQ" + | ||
51 | "ASLmCAoLVGVzdE1lc3NhZ2USEQoDeHhkGBQgASgBOgQxMC4zEgsKA3h4ZhgV" + | ||
52 | "IAEoAhINCgV4eHUzMhgWIAEoDRILCgN4eHMYFyABKAkSCwoDeHhiGBggASgM" + | ||
53 | "EgwKBHh4c3MYGSADKAkSDAoEeHhiYhgaIAMoDBIQCgR4eGZmGBsgAygCQgIQ" + | ||
54 | "ARIQCgR4eG5uGB0gAygCQgIQARIMCgR4eGZyGBwgAigCEg0KAW4YASADKAJC" + | ||
55 | "AhABEg8KA3YyZhgCIAMoAkICEAESDwoDdjJkGAMgAygBQgIQARIPCgN2M2YY" + | ||
56 | "BCADKAJCAhABEg8KA3YzZBgFIAMoAUICEAESDwoDdjRmGAYgAygCQgIQARIP" + | ||
57 | "CgN2NGQYByADKAFCAhABEg0KAXEYCCADKAJCAhABEgkKAXUYCSABKAwSCQoB" + | ||
58 | "YRgKIAEoAhIJCgF0GAsgASgGEgkKAWQYDCABKBASCwoDZjMyGA0gASgNEgsK" + | ||
59 | "A2Y2NBgOIAEoBBIPCgNic2YYDyADKAJCAhABEg8KA2JzZBgQIAMoAUICEAES" + | ||
60 | "DwoDYmJmGBEgAygCQgIQARIPCgNiYmQYEiADKAFCAhABEjoKA2UzMhgTIAEo" + | ||
61 | "DjItLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuVGVzdE1lc3NhZ2UuRW51" + | ||
62 | "bTMyEkEKBnN1Ym1lcxgeIAEoCzIxLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJu" + | ||
63 | "YWwuVGVzdE1lc3NhZ2UuU3ViTWVzc2FnZRJFCgpzdWJtZXNzZXJzGB8gAygL" + | ||
64 | "MjEuU2lyaWthdGEuUEIuX1BCSl9JbnRlcm5hbC5UZXN0TWVzc2FnZS5TdWJN" + | ||
65 | "ZXNzYWdlEgsKA3NoYRggIAEoDBIMCgRzaGFzGCEgAygMEjoKBmV4dG1lcxgi" + | ||
66 | "IAEoCzIqLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuRXh0ZXJuYWxNZXNz" + | ||
67 | "YWdlEj4KCmV4dG1lc3NlcnMYIyADKAsyKi5TaXJpa2F0YS5QQi5fUEJKX0lu" + | ||
68 | "dGVybmFsLkV4dGVybmFsTWVzc2FnZRI9CglleHRtZXNzZXIYJCACKAsyKi5T" + | ||
69 | "aXJpa2F0YS5QQi5fUEJKX0ludGVybmFsLkV4dGVybmFsTWVzc2FnZRpgCgpT" + | ||
70 | "dWJNZXNzYWdlEg8KB3N1YnV1aWQYASABKAwSFQoJc3VidmVjdG9yGAIgAygB" + | ||
71 | "QgIQARITCgtzdWJkdXJhdGlvbhgDIAEoEBIVCglzdWJub3JtYWwYBCADKAJC" + | ||
72 | "AhABIjUKCEZsYWdzZjMyEgwKCFVOSVZFUlNBEAASBgoCV0UQARIJCgVJTUFH" + | ||
73 | "RRACEggKBExPQ0EQAyI5CghGbGFnc2Y2NBINCglVTklWRVJTQUwQABIHCgNX" + | ||
74 | "RUIQARIKCgZJTUFHRVMQAhIJCgVMT0NBTBADIjsKBkVudW0zMhIOCgpVTklW" + | ||
75 | "RVJTQUwxEAASCAoEV0VCMRABEgsKB0lNQUdFUzEQAhIKCgZMT0NBTDEQAyoF" + | ||
76 | "CGQQyAE6QQoNZXh0ZW5zaW9uYmJveBImLlNpcmlrYXRhLlBCLl9QQkpfSW50" + | ||
77 | "ZXJuYWwuVGVzdE1lc3NhZ2UYZCADKAJCAhABOkMKD2V4dGVuc2lvbnZlY3Rv" + | ||
78 | "chImLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuVGVzdE1lc3NhZ2UYZSAD" + | ||
79 | "KAJCAhAB"); | ||
80 | pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | ||
81 | descriptor = root; | ||
82 | internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor = Descriptor.MessageTypes[0]; | ||
83 | internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable = | ||
84 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor, | ||
85 | new string[] { "IsTrue", "V2F", "SubMes", "Submessers", "Sha", "Shas", "V3F", "V3Ff", }); | ||
86 | internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor = internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor.NestedTypes[0]; | ||
87 | internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable = | ||
88 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor, | ||
89 | new string[] { "Subuuid", "Subvector", "Subduration", "Subnormal", }); | ||
90 | internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor = Descriptor.MessageTypes[1]; | ||
91 | internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable = | ||
92 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor, | ||
93 | new string[] { "Xxd", "Xxf", "Xxu32", "Xxs", "Xxb", "Xxss", "Xxbb", "Xxff", "Xxnn", "Xxfr", "N", "V2F", "V2D", "V3F", "V3D", "V4F", "V4D", "Q", "U", "A", "T", "D", "F32", "F64", "Bsf", "Bsd", "Bbf", "Bbd", "E32", "Submes", "Submessers", "Sha", "Shas", "Extmes", "Extmessers", "Extmesser", }); | ||
94 | internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor = internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor.NestedTypes[0]; | ||
95 | internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable = | ||
96 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor, | ||
97 | new string[] { "Subuuid", "Subvector", "Subduration", "Subnormal", }); | ||
98 | global::Sirikata.PB._PBJ_Internal.Test.Extensionbbox = pb::GeneratedRepeatExtension<float>.CreateInstance(global::Sirikata.PB._PBJ_Internal.Test.Descriptor.Extensions[0]); | ||
99 | global::Sirikata.PB._PBJ_Internal.Test.Extensionvector = pb::GeneratedRepeatExtension<float>.CreateInstance(global::Sirikata.PB._PBJ_Internal.Test.Descriptor.Extensions[1]); | ||
100 | return null; | ||
101 | }; | ||
102 | pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | ||
103 | new pbd::FileDescriptor[] { | ||
104 | }, assigner); | ||
105 | } | ||
106 | #endregion | ||
107 | |||
108 | } | ||
109 | #region Messages | ||
110 | public sealed partial class ExternalMessage : pb::GeneratedMessage<ExternalMessage, ExternalMessage.Builder> { | ||
111 | private static readonly ExternalMessage defaultInstance = new Builder().BuildPartial(); | ||
112 | public static ExternalMessage DefaultInstance { | ||
113 | get { return defaultInstance; } | ||
114 | } | ||
115 | |||
116 | public override ExternalMessage DefaultInstanceForType { | ||
117 | get { return defaultInstance; } | ||
118 | } | ||
119 | |||
120 | protected override ExternalMessage ThisMessage { | ||
121 | get { return this; } | ||
122 | } | ||
123 | |||
124 | public static pbd::MessageDescriptor Descriptor { | ||
125 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor; } | ||
126 | } | ||
127 | |||
128 | protected override pb::FieldAccess.FieldAccessorTable<ExternalMessage, ExternalMessage.Builder> InternalFieldAccessors { | ||
129 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable; } | ||
130 | } | ||
131 | |||
132 | #region Nested types | ||
133 | public static class Types { | ||
134 | public sealed partial class SubMessage : pb::GeneratedMessage<SubMessage, SubMessage.Builder> { | ||
135 | private static readonly SubMessage defaultInstance = new Builder().BuildPartial(); | ||
136 | public static SubMessage DefaultInstance { | ||
137 | get { return defaultInstance; } | ||
138 | } | ||
139 | |||
140 | public override SubMessage DefaultInstanceForType { | ||
141 | get { return defaultInstance; } | ||
142 | } | ||
143 | |||
144 | protected override SubMessage ThisMessage { | ||
145 | get { return this; } | ||
146 | } | ||
147 | |||
148 | public static pbd::MessageDescriptor Descriptor { | ||
149 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor; } | ||
150 | } | ||
151 | |||
152 | protected override pb::FieldAccess.FieldAccessorTable<SubMessage, SubMessage.Builder> InternalFieldAccessors { | ||
153 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable; } | ||
154 | } | ||
155 | |||
156 | public const int SubuuidFieldNumber = 1; | ||
157 | private bool hasSubuuid; | ||
158 | private pb::ByteString subuuid_ = pb::ByteString.Empty; | ||
159 | public bool HasSubuuid { | ||
160 | get { return hasSubuuid; } | ||
161 | } | ||
162 | public pb::ByteString Subuuid { | ||
163 | get { return subuuid_; } | ||
164 | } | ||
165 | |||
166 | public const int SubvectorFieldNumber = 2; | ||
167 | private int subvectorMemoizedSerializedSize; | ||
168 | private pbc::PopsicleList<double> subvector_ = new pbc::PopsicleList<double>(); | ||
169 | public scg::IList<double> SubvectorList { | ||
170 | get { return pbc::Lists.AsReadOnly(subvector_); } | ||
171 | } | ||
172 | public int SubvectorCount { | ||
173 | get { return subvector_.Count; } | ||
174 | } | ||
175 | public double GetSubvector(int index) { | ||
176 | return subvector_[index]; | ||
177 | } | ||
178 | |||
179 | public const int SubdurationFieldNumber = 3; | ||
180 | private bool hasSubduration; | ||
181 | private long subduration_ = 0; | ||
182 | public bool HasSubduration { | ||
183 | get { return hasSubduration; } | ||
184 | } | ||
185 | public long Subduration { | ||
186 | get { return subduration_; } | ||
187 | } | ||
188 | |||
189 | public const int SubnormalFieldNumber = 4; | ||
190 | private int subnormalMemoizedSerializedSize; | ||
191 | private pbc::PopsicleList<float> subnormal_ = new pbc::PopsicleList<float>(); | ||
192 | public scg::IList<float> SubnormalList { | ||
193 | get { return pbc::Lists.AsReadOnly(subnormal_); } | ||
194 | } | ||
195 | public int SubnormalCount { | ||
196 | get { return subnormal_.Count; } | ||
197 | } | ||
198 | public float GetSubnormal(int index) { | ||
199 | return subnormal_[index]; | ||
200 | } | ||
201 | |||
202 | public override bool IsInitialized { | ||
203 | get { | ||
204 | return true; | ||
205 | } | ||
206 | } | ||
207 | |||
208 | public override void WriteTo(pb::CodedOutputStream output) { | ||
209 | if (HasSubuuid) { | ||
210 | output.WriteBytes(1, Subuuid); | ||
211 | } | ||
212 | if (subvector_.Count > 0) { | ||
213 | output.WriteRawVarint32(18); | ||
214 | output.WriteRawVarint32((uint) subvectorMemoizedSerializedSize); | ||
215 | foreach (double element in subvector_) { | ||
216 | output.WriteDoubleNoTag(element); | ||
217 | } | ||
218 | } | ||
219 | if (HasSubduration) { | ||
220 | output.WriteSFixed64(3, Subduration); | ||
221 | } | ||
222 | if (subnormal_.Count > 0) { | ||
223 | output.WriteRawVarint32(34); | ||
224 | output.WriteRawVarint32((uint) subnormalMemoizedSerializedSize); | ||
225 | foreach (float element in subnormal_) { | ||
226 | output.WriteFloatNoTag(element); | ||
227 | } | ||
228 | } | ||
229 | UnknownFields.WriteTo(output); | ||
230 | } | ||
231 | |||
232 | private int memoizedSerializedSize = -1; | ||
233 | public override int SerializedSize { | ||
234 | get { | ||
235 | int size = memoizedSerializedSize; | ||
236 | if (size != -1) return size; | ||
237 | |||
238 | size = 0; | ||
239 | if (HasSubuuid) { | ||
240 | size += pb::CodedOutputStream.ComputeBytesSize(1, Subuuid); | ||
241 | } | ||
242 | { | ||
243 | int dataSize = 0; | ||
244 | dataSize = 8 * subvector_.Count; | ||
245 | size += dataSize; | ||
246 | if (subvector_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
247 | subvectorMemoizedSerializedSize = dataSize; | ||
248 | } | ||
249 | if (HasSubduration) { | ||
250 | size += pb::CodedOutputStream.ComputeSFixed64Size(3, Subduration); | ||
251 | } | ||
252 | { | ||
253 | int dataSize = 0; | ||
254 | dataSize = 4 * subnormal_.Count; | ||
255 | size += dataSize; | ||
256 | if (subnormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
257 | subnormalMemoizedSerializedSize = dataSize; | ||
258 | } | ||
259 | size += UnknownFields.SerializedSize; | ||
260 | memoizedSerializedSize = size; | ||
261 | return size; | ||
262 | } | ||
263 | } | ||
264 | |||
265 | public static SubMessage ParseFrom(pb::ByteString data) { | ||
266 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
267 | } | ||
268 | public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
269 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
270 | } | ||
271 | public static SubMessage ParseFrom(byte[] data) { | ||
272 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
273 | } | ||
274 | public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
275 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
276 | } | ||
277 | public static SubMessage ParseFrom(global::System.IO.Stream input) { | ||
278 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
279 | } | ||
280 | public static SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
281 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
282 | } | ||
283 | public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input) { | ||
284 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
285 | } | ||
286 | public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
287 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
288 | } | ||
289 | public static SubMessage ParseFrom(pb::CodedInputStream input) { | ||
290 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
291 | } | ||
292 | public static SubMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
293 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
294 | } | ||
295 | public static Builder CreateBuilder() { return new Builder(); } | ||
296 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
297 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
298 | public static Builder CreateBuilder(SubMessage prototype) { | ||
299 | return (Builder) new Builder().MergeFrom(prototype); | ||
300 | } | ||
301 | |||
302 | public sealed partial class Builder : pb::GeneratedBuilder<SubMessage, Builder> { | ||
303 | protected override Builder ThisBuilder { | ||
304 | get { return this; } | ||
305 | } | ||
306 | public Builder() {} | ||
307 | |||
308 | SubMessage result = new SubMessage(); | ||
309 | |||
310 | protected override SubMessage MessageBeingBuilt { | ||
311 | get { return result; } | ||
312 | } | ||
313 | |||
314 | public override Builder Clear() { | ||
315 | result = new SubMessage(); | ||
316 | return this; | ||
317 | } | ||
318 | |||
319 | public override Builder Clone() { | ||
320 | return new Builder().MergeFrom(result); | ||
321 | } | ||
322 | |||
323 | public override pbd::MessageDescriptor DescriptorForType { | ||
324 | get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Descriptor; } | ||
325 | } | ||
326 | |||
327 | public override SubMessage DefaultInstanceForType { | ||
328 | get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance; } | ||
329 | } | ||
330 | |||
331 | public override SubMessage BuildPartial() { | ||
332 | if (result == null) { | ||
333 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
334 | } | ||
335 | result.subvector_.MakeReadOnly(); | ||
336 | result.subnormal_.MakeReadOnly(); | ||
337 | SubMessage returnMe = result; | ||
338 | result = null; | ||
339 | return returnMe; | ||
340 | } | ||
341 | |||
342 | public override Builder MergeFrom(pb::IMessage other) { | ||
343 | if (other is SubMessage) { | ||
344 | return MergeFrom((SubMessage) other); | ||
345 | } else { | ||
346 | base.MergeFrom(other); | ||
347 | return this; | ||
348 | } | ||
349 | } | ||
350 | |||
351 | public override Builder MergeFrom(SubMessage other) { | ||
352 | if (other == global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance) return this; | ||
353 | if (other.HasSubuuid) { | ||
354 | Subuuid = other.Subuuid; | ||
355 | } | ||
356 | if (other.subvector_.Count != 0) { | ||
357 | base.AddRange(other.subvector_, result.subvector_); | ||
358 | } | ||
359 | if (other.HasSubduration) { | ||
360 | Subduration = other.Subduration; | ||
361 | } | ||
362 | if (other.subnormal_.Count != 0) { | ||
363 | base.AddRange(other.subnormal_, result.subnormal_); | ||
364 | } | ||
365 | this.MergeUnknownFields(other.UnknownFields); | ||
366 | return this; | ||
367 | } | ||
368 | |||
369 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
370 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
371 | } | ||
372 | |||
373 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
374 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
375 | while (true) { | ||
376 | uint tag = input.ReadTag(); | ||
377 | switch (tag) { | ||
378 | case 0: { | ||
379 | if (unknownFields != null) { | ||
380 | this.UnknownFields = unknownFields.Build(); | ||
381 | } | ||
382 | return this; | ||
383 | } | ||
384 | default: { | ||
385 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
386 | if (unknownFields != null) { | ||
387 | this.UnknownFields = unknownFields.Build(); | ||
388 | } | ||
389 | return this; | ||
390 | } | ||
391 | if (unknownFields == null) { | ||
392 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
393 | } | ||
394 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
395 | break; | ||
396 | } | ||
397 | case 10: { | ||
398 | Subuuid = input.ReadBytes(); | ||
399 | break; | ||
400 | } | ||
401 | case 18: { | ||
402 | int length = input.ReadInt32(); | ||
403 | int limit = input.PushLimit(length); | ||
404 | while (!input.ReachedLimit) { | ||
405 | AddSubvector(input.ReadDouble()); | ||
406 | } | ||
407 | input.PopLimit(limit); | ||
408 | break; | ||
409 | } | ||
410 | case 25: { | ||
411 | Subduration = input.ReadSFixed64(); | ||
412 | break; | ||
413 | } | ||
414 | case 34: { | ||
415 | int length = input.ReadInt32(); | ||
416 | int limit = input.PushLimit(length); | ||
417 | while (!input.ReachedLimit) { | ||
418 | AddSubnormal(input.ReadFloat()); | ||
419 | } | ||
420 | input.PopLimit(limit); | ||
421 | break; | ||
422 | } | ||
423 | } | ||
424 | } | ||
425 | } | ||
426 | |||
427 | |||
428 | public bool HasSubuuid { | ||
429 | get { return result.HasSubuuid; } | ||
430 | } | ||
431 | public pb::ByteString Subuuid { | ||
432 | get { return result.Subuuid; } | ||
433 | set { SetSubuuid(value); } | ||
434 | } | ||
435 | public Builder SetSubuuid(pb::ByteString value) { | ||
436 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
437 | result.hasSubuuid = true; | ||
438 | result.subuuid_ = value; | ||
439 | return this; | ||
440 | } | ||
441 | public Builder ClearSubuuid() { | ||
442 | result.hasSubuuid = false; | ||
443 | result.subuuid_ = pb::ByteString.Empty; | ||
444 | return this; | ||
445 | } | ||
446 | |||
447 | public pbc::IPopsicleList<double> SubvectorList { | ||
448 | get { return result.subvector_; } | ||
449 | } | ||
450 | public int SubvectorCount { | ||
451 | get { return result.SubvectorCount; } | ||
452 | } | ||
453 | public double GetSubvector(int index) { | ||
454 | return result.GetSubvector(index); | ||
455 | } | ||
456 | public Builder SetSubvector(int index, double value) { | ||
457 | result.subvector_[index] = value; | ||
458 | return this; | ||
459 | } | ||
460 | public Builder AddSubvector(double value) { | ||
461 | result.subvector_.Add(value); | ||
462 | return this; | ||
463 | } | ||
464 | public Builder AddRangeSubvector(scg::IEnumerable<double> values) { | ||
465 | base.AddRange(values, result.subvector_); | ||
466 | return this; | ||
467 | } | ||
468 | public Builder ClearSubvector() { | ||
469 | result.subvector_.Clear(); | ||
470 | return this; | ||
471 | } | ||
472 | |||
473 | public bool HasSubduration { | ||
474 | get { return result.HasSubduration; } | ||
475 | } | ||
476 | public long Subduration { | ||
477 | get { return result.Subduration; } | ||
478 | set { SetSubduration(value); } | ||
479 | } | ||
480 | public Builder SetSubduration(long value) { | ||
481 | result.hasSubduration = true; | ||
482 | result.subduration_ = value; | ||
483 | return this; | ||
484 | } | ||
485 | public Builder ClearSubduration() { | ||
486 | result.hasSubduration = false; | ||
487 | result.subduration_ = 0; | ||
488 | return this; | ||
489 | } | ||
490 | |||
491 | public pbc::IPopsicleList<float> SubnormalList { | ||
492 | get { return result.subnormal_; } | ||
493 | } | ||
494 | public int SubnormalCount { | ||
495 | get { return result.SubnormalCount; } | ||
496 | } | ||
497 | public float GetSubnormal(int index) { | ||
498 | return result.GetSubnormal(index); | ||
499 | } | ||
500 | public Builder SetSubnormal(int index, float value) { | ||
501 | result.subnormal_[index] = value; | ||
502 | return this; | ||
503 | } | ||
504 | public Builder AddSubnormal(float value) { | ||
505 | result.subnormal_.Add(value); | ||
506 | return this; | ||
507 | } | ||
508 | public Builder AddRangeSubnormal(scg::IEnumerable<float> values) { | ||
509 | base.AddRange(values, result.subnormal_); | ||
510 | return this; | ||
511 | } | ||
512 | public Builder ClearSubnormal() { | ||
513 | result.subnormal_.Clear(); | ||
514 | return this; | ||
515 | } | ||
516 | } | ||
517 | static SubMessage() { | ||
518 | object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); | ||
519 | } | ||
520 | } | ||
521 | |||
522 | } | ||
523 | #endregion | ||
524 | |||
525 | public const int IsTrueFieldNumber = 40; | ||
526 | private bool hasIsTrue; | ||
527 | private bool isTrue_ = true; | ||
528 | public bool HasIsTrue { | ||
529 | get { return hasIsTrue; } | ||
530 | } | ||
531 | public bool IsTrue { | ||
532 | get { return isTrue_; } | ||
533 | } | ||
534 | |||
535 | public const int V2FFieldNumber = 2; | ||
536 | private int v2FMemoizedSerializedSize; | ||
537 | private pbc::PopsicleList<float> v2F_ = new pbc::PopsicleList<float>(); | ||
538 | public scg::IList<float> V2FList { | ||
539 | get { return pbc::Lists.AsReadOnly(v2F_); } | ||
540 | } | ||
541 | public int V2FCount { | ||
542 | get { return v2F_.Count; } | ||
543 | } | ||
544 | public float GetV2F(int index) { | ||
545 | return v2F_[index]; | ||
546 | } | ||
547 | |||
548 | public const int SubMesFieldNumber = 30; | ||
549 | private bool hasSubMes; | ||
550 | private global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance; | ||
551 | public bool HasSubMes { | ||
552 | get { return hasSubMes; } | ||
553 | } | ||
554 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage SubMes { | ||
555 | get { return subMes_; } | ||
556 | } | ||
557 | |||
558 | public const int SubmessersFieldNumber = 31; | ||
559 | private pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> submessers_ = new pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage>(); | ||
560 | public scg::IList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> SubmessersList { | ||
561 | get { return submessers_; } | ||
562 | } | ||
563 | public int SubmessersCount { | ||
564 | get { return submessers_.Count; } | ||
565 | } | ||
566 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage GetSubmessers(int index) { | ||
567 | return submessers_[index]; | ||
568 | } | ||
569 | |||
570 | public const int ShaFieldNumber = 32; | ||
571 | private bool hasSha; | ||
572 | private pb::ByteString sha_ = pb::ByteString.Empty; | ||
573 | public bool HasSha { | ||
574 | get { return hasSha; } | ||
575 | } | ||
576 | public pb::ByteString Sha { | ||
577 | get { return sha_; } | ||
578 | } | ||
579 | |||
580 | public const int ShasFieldNumber = 33; | ||
581 | private pbc::PopsicleList<pb::ByteString> shas_ = new pbc::PopsicleList<pb::ByteString>(); | ||
582 | public scg::IList<pb::ByteString> ShasList { | ||
583 | get { return pbc::Lists.AsReadOnly(shas_); } | ||
584 | } | ||
585 | public int ShasCount { | ||
586 | get { return shas_.Count; } | ||
587 | } | ||
588 | public pb::ByteString GetShas(int index) { | ||
589 | return shas_[index]; | ||
590 | } | ||
591 | |||
592 | public const int V3FFieldNumber = 4; | ||
593 | private int v3FMemoizedSerializedSize; | ||
594 | private pbc::PopsicleList<float> v3F_ = new pbc::PopsicleList<float>(); | ||
595 | public scg::IList<float> V3FList { | ||
596 | get { return pbc::Lists.AsReadOnly(v3F_); } | ||
597 | } | ||
598 | public int V3FCount { | ||
599 | get { return v3F_.Count; } | ||
600 | } | ||
601 | public float GetV3F(int index) { | ||
602 | return v3F_[index]; | ||
603 | } | ||
604 | |||
605 | public const int V3FfFieldNumber = 5; | ||
606 | private int v3FfMemoizedSerializedSize; | ||
607 | private pbc::PopsicleList<float> v3Ff_ = new pbc::PopsicleList<float>(); | ||
608 | public scg::IList<float> V3FfList { | ||
609 | get { return pbc::Lists.AsReadOnly(v3Ff_); } | ||
610 | } | ||
611 | public int V3FfCount { | ||
612 | get { return v3Ff_.Count; } | ||
613 | } | ||
614 | public float GetV3Ff(int index) { | ||
615 | return v3Ff_[index]; | ||
616 | } | ||
617 | |||
618 | public override bool IsInitialized { | ||
619 | get { | ||
620 | return true; | ||
621 | } | ||
622 | } | ||
623 | |||
624 | public override void WriteTo(pb::CodedOutputStream output) { | ||
625 | if (v2F_.Count > 0) { | ||
626 | output.WriteRawVarint32(18); | ||
627 | output.WriteRawVarint32((uint) v2FMemoizedSerializedSize); | ||
628 | foreach (float element in v2F_) { | ||
629 | output.WriteFloatNoTag(element); | ||
630 | } | ||
631 | } | ||
632 | if (v3F_.Count > 0) { | ||
633 | output.WriteRawVarint32(34); | ||
634 | output.WriteRawVarint32((uint) v3FMemoizedSerializedSize); | ||
635 | foreach (float element in v3F_) { | ||
636 | output.WriteFloatNoTag(element); | ||
637 | } | ||
638 | } | ||
639 | if (v3Ff_.Count > 0) { | ||
640 | output.WriteRawVarint32(42); | ||
641 | output.WriteRawVarint32((uint) v3FfMemoizedSerializedSize); | ||
642 | foreach (float element in v3Ff_) { | ||
643 | output.WriteFloatNoTag(element); | ||
644 | } | ||
645 | } | ||
646 | if (HasSubMes) { | ||
647 | output.WriteMessage(30, SubMes); | ||
648 | } | ||
649 | foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage element in SubmessersList) { | ||
650 | output.WriteMessage(31, element); | ||
651 | } | ||
652 | if (HasSha) { | ||
653 | output.WriteBytes(32, Sha); | ||
654 | } | ||
655 | if (shas_.Count > 0) { | ||
656 | foreach (pb::ByteString element in shas_) { | ||
657 | output.WriteBytes(33, element); | ||
658 | } | ||
659 | } | ||
660 | if (HasIsTrue) { | ||
661 | output.WriteBool(40, IsTrue); | ||
662 | } | ||
663 | UnknownFields.WriteTo(output); | ||
664 | } | ||
665 | |||
666 | private int memoizedSerializedSize = -1; | ||
667 | public override int SerializedSize { | ||
668 | get { | ||
669 | int size = memoizedSerializedSize; | ||
670 | if (size != -1) return size; | ||
671 | |||
672 | size = 0; | ||
673 | if (HasIsTrue) { | ||
674 | size += pb::CodedOutputStream.ComputeBoolSize(40, IsTrue); | ||
675 | } | ||
676 | { | ||
677 | int dataSize = 0; | ||
678 | dataSize = 4 * v2F_.Count; | ||
679 | size += dataSize; | ||
680 | if (v2F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
681 | v2FMemoizedSerializedSize = dataSize; | ||
682 | } | ||
683 | if (HasSubMes) { | ||
684 | size += pb::CodedOutputStream.ComputeMessageSize(30, SubMes); | ||
685 | } | ||
686 | foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage element in SubmessersList) { | ||
687 | size += pb::CodedOutputStream.ComputeMessageSize(31, element); | ||
688 | } | ||
689 | if (HasSha) { | ||
690 | size += pb::CodedOutputStream.ComputeBytesSize(32, Sha); | ||
691 | } | ||
692 | { | ||
693 | int dataSize = 0; | ||
694 | foreach (pb::ByteString element in ShasList) { | ||
695 | dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); | ||
696 | } | ||
697 | size += dataSize; | ||
698 | size += 2 * shas_.Count; | ||
699 | } | ||
700 | { | ||
701 | int dataSize = 0; | ||
702 | dataSize = 4 * v3F_.Count; | ||
703 | size += dataSize; | ||
704 | if (v3F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
705 | v3FMemoizedSerializedSize = dataSize; | ||
706 | } | ||
707 | { | ||
708 | int dataSize = 0; | ||
709 | dataSize = 4 * v3Ff_.Count; | ||
710 | size += dataSize; | ||
711 | if (v3Ff_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
712 | v3FfMemoizedSerializedSize = dataSize; | ||
713 | } | ||
714 | size += UnknownFields.SerializedSize; | ||
715 | memoizedSerializedSize = size; | ||
716 | return size; | ||
717 | } | ||
718 | } | ||
719 | |||
720 | public static ExternalMessage ParseFrom(pb::ByteString data) { | ||
721 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
722 | } | ||
723 | public static ExternalMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
724 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
725 | } | ||
726 | public static ExternalMessage ParseFrom(byte[] data) { | ||
727 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
728 | } | ||
729 | public static ExternalMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
730 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
731 | } | ||
732 | public static ExternalMessage ParseFrom(global::System.IO.Stream input) { | ||
733 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
734 | } | ||
735 | public static ExternalMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
736 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
737 | } | ||
738 | public static ExternalMessage ParseDelimitedFrom(global::System.IO.Stream input) { | ||
739 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
740 | } | ||
741 | public static ExternalMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
742 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
743 | } | ||
744 | public static ExternalMessage ParseFrom(pb::CodedInputStream input) { | ||
745 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
746 | } | ||
747 | public static ExternalMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
748 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
749 | } | ||
750 | public static Builder CreateBuilder() { return new Builder(); } | ||
751 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
752 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
753 | public static Builder CreateBuilder(ExternalMessage prototype) { | ||
754 | return (Builder) new Builder().MergeFrom(prototype); | ||
755 | } | ||
756 | |||
757 | public sealed partial class Builder : pb::GeneratedBuilder<ExternalMessage, Builder> { | ||
758 | protected override Builder ThisBuilder { | ||
759 | get { return this; } | ||
760 | } | ||
761 | public Builder() {} | ||
762 | |||
763 | ExternalMessage result = new ExternalMessage(); | ||
764 | |||
765 | protected override ExternalMessage MessageBeingBuilt { | ||
766 | get { return result; } | ||
767 | } | ||
768 | |||
769 | public override Builder Clear() { | ||
770 | result = new ExternalMessage(); | ||
771 | return this; | ||
772 | } | ||
773 | |||
774 | public override Builder Clone() { | ||
775 | return new Builder().MergeFrom(result); | ||
776 | } | ||
777 | |||
778 | public override pbd::MessageDescriptor DescriptorForType { | ||
779 | get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Descriptor; } | ||
780 | } | ||
781 | |||
782 | public override ExternalMessage DefaultInstanceForType { | ||
783 | get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; } | ||
784 | } | ||
785 | |||
786 | public override ExternalMessage BuildPartial() { | ||
787 | if (result == null) { | ||
788 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
789 | } | ||
790 | result.v2F_.MakeReadOnly(); | ||
791 | result.submessers_.MakeReadOnly(); | ||
792 | result.shas_.MakeReadOnly(); | ||
793 | result.v3F_.MakeReadOnly(); | ||
794 | result.v3Ff_.MakeReadOnly(); | ||
795 | ExternalMessage returnMe = result; | ||
796 | result = null; | ||
797 | return returnMe; | ||
798 | } | ||
799 | |||
800 | public override Builder MergeFrom(pb::IMessage other) { | ||
801 | if (other is ExternalMessage) { | ||
802 | return MergeFrom((ExternalMessage) other); | ||
803 | } else { | ||
804 | base.MergeFrom(other); | ||
805 | return this; | ||
806 | } | ||
807 | } | ||
808 | |||
809 | public override Builder MergeFrom(ExternalMessage other) { | ||
810 | if (other == global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) return this; | ||
811 | if (other.HasIsTrue) { | ||
812 | IsTrue = other.IsTrue; | ||
813 | } | ||
814 | if (other.v2F_.Count != 0) { | ||
815 | base.AddRange(other.v2F_, result.v2F_); | ||
816 | } | ||
817 | if (other.HasSubMes) { | ||
818 | MergeSubMes(other.SubMes); | ||
819 | } | ||
820 | if (other.submessers_.Count != 0) { | ||
821 | base.AddRange(other.submessers_, result.submessers_); | ||
822 | } | ||
823 | if (other.HasSha) { | ||
824 | Sha = other.Sha; | ||
825 | } | ||
826 | if (other.shas_.Count != 0) { | ||
827 | base.AddRange(other.shas_, result.shas_); | ||
828 | } | ||
829 | if (other.v3F_.Count != 0) { | ||
830 | base.AddRange(other.v3F_, result.v3F_); | ||
831 | } | ||
832 | if (other.v3Ff_.Count != 0) { | ||
833 | base.AddRange(other.v3Ff_, result.v3Ff_); | ||
834 | } | ||
835 | this.MergeUnknownFields(other.UnknownFields); | ||
836 | return this; | ||
837 | } | ||
838 | |||
839 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
840 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
841 | } | ||
842 | |||
843 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
844 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
845 | while (true) { | ||
846 | uint tag = input.ReadTag(); | ||
847 | switch (tag) { | ||
848 | case 0: { | ||
849 | if (unknownFields != null) { | ||
850 | this.UnknownFields = unknownFields.Build(); | ||
851 | } | ||
852 | return this; | ||
853 | } | ||
854 | default: { | ||
855 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
856 | if (unknownFields != null) { | ||
857 | this.UnknownFields = unknownFields.Build(); | ||
858 | } | ||
859 | return this; | ||
860 | } | ||
861 | if (unknownFields == null) { | ||
862 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
863 | } | ||
864 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
865 | break; | ||
866 | } | ||
867 | case 18: { | ||
868 | int length = input.ReadInt32(); | ||
869 | int limit = input.PushLimit(length); | ||
870 | while (!input.ReachedLimit) { | ||
871 | AddV2F(input.ReadFloat()); | ||
872 | } | ||
873 | input.PopLimit(limit); | ||
874 | break; | ||
875 | } | ||
876 | case 34: { | ||
877 | int length = input.ReadInt32(); | ||
878 | int limit = input.PushLimit(length); | ||
879 | while (!input.ReachedLimit) { | ||
880 | AddV3F(input.ReadFloat()); | ||
881 | } | ||
882 | input.PopLimit(limit); | ||
883 | break; | ||
884 | } | ||
885 | case 42: { | ||
886 | int length = input.ReadInt32(); | ||
887 | int limit = input.PushLimit(length); | ||
888 | while (!input.ReachedLimit) { | ||
889 | AddV3Ff(input.ReadFloat()); | ||
890 | } | ||
891 | input.PopLimit(limit); | ||
892 | break; | ||
893 | } | ||
894 | case 242: { | ||
895 | global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder(); | ||
896 | if (HasSubMes) { | ||
897 | subBuilder.MergeFrom(SubMes); | ||
898 | } | ||
899 | input.ReadMessage(subBuilder, extensionRegistry); | ||
900 | SubMes = subBuilder.BuildPartial(); | ||
901 | break; | ||
902 | } | ||
903 | case 250: { | ||
904 | global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder(); | ||
905 | input.ReadMessage(subBuilder, extensionRegistry); | ||
906 | AddSubmessers(subBuilder.BuildPartial()); | ||
907 | break; | ||
908 | } | ||
909 | case 258: { | ||
910 | Sha = input.ReadBytes(); | ||
911 | break; | ||
912 | } | ||
913 | case 266: { | ||
914 | AddShas(input.ReadBytes()); | ||
915 | break; | ||
916 | } | ||
917 | case 320: { | ||
918 | IsTrue = input.ReadBool(); | ||
919 | break; | ||
920 | } | ||
921 | } | ||
922 | } | ||
923 | } | ||
924 | |||
925 | |||
926 | public bool HasIsTrue { | ||
927 | get { return result.HasIsTrue; } | ||
928 | } | ||
929 | public bool IsTrue { | ||
930 | get { return result.IsTrue; } | ||
931 | set { SetIsTrue(value); } | ||
932 | } | ||
933 | public Builder SetIsTrue(bool value) { | ||
934 | result.hasIsTrue = true; | ||
935 | result.isTrue_ = value; | ||
936 | return this; | ||
937 | } | ||
938 | public Builder ClearIsTrue() { | ||
939 | result.hasIsTrue = false; | ||
940 | result.isTrue_ = true; | ||
941 | return this; | ||
942 | } | ||
943 | |||
944 | public pbc::IPopsicleList<float> V2FList { | ||
945 | get { return result.v2F_; } | ||
946 | } | ||
947 | public int V2FCount { | ||
948 | get { return result.V2FCount; } | ||
949 | } | ||
950 | public float GetV2F(int index) { | ||
951 | return result.GetV2F(index); | ||
952 | } | ||
953 | public Builder SetV2F(int index, float value) { | ||
954 | result.v2F_[index] = value; | ||
955 | return this; | ||
956 | } | ||
957 | public Builder AddV2F(float value) { | ||
958 | result.v2F_.Add(value); | ||
959 | return this; | ||
960 | } | ||
961 | public Builder AddRangeV2F(scg::IEnumerable<float> values) { | ||
962 | base.AddRange(values, result.v2F_); | ||
963 | return this; | ||
964 | } | ||
965 | public Builder ClearV2F() { | ||
966 | result.v2F_.Clear(); | ||
967 | return this; | ||
968 | } | ||
969 | |||
970 | public bool HasSubMes { | ||
971 | get { return result.HasSubMes; } | ||
972 | } | ||
973 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage SubMes { | ||
974 | get { return result.SubMes; } | ||
975 | set { SetSubMes(value); } | ||
976 | } | ||
977 | public Builder SetSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { | ||
978 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
979 | result.hasSubMes = true; | ||
980 | result.subMes_ = value; | ||
981 | return this; | ||
982 | } | ||
983 | public Builder SetSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) { | ||
984 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
985 | result.hasSubMes = true; | ||
986 | result.subMes_ = builderForValue.Build(); | ||
987 | return this; | ||
988 | } | ||
989 | public Builder MergeSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { | ||
990 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
991 | if (result.HasSubMes && | ||
992 | result.subMes_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance) { | ||
993 | result.subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder(result.subMes_).MergeFrom(value).BuildPartial(); | ||
994 | } else { | ||
995 | result.subMes_ = value; | ||
996 | } | ||
997 | result.hasSubMes = true; | ||
998 | return this; | ||
999 | } | ||
1000 | public Builder ClearSubMes() { | ||
1001 | result.hasSubMes = false; | ||
1002 | result.subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance; | ||
1003 | return this; | ||
1004 | } | ||
1005 | |||
1006 | public pbc::IPopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> SubmessersList { | ||
1007 | get { return result.submessers_; } | ||
1008 | } | ||
1009 | public int SubmessersCount { | ||
1010 | get { return result.SubmessersCount; } | ||
1011 | } | ||
1012 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage GetSubmessers(int index) { | ||
1013 | return result.GetSubmessers(index); | ||
1014 | } | ||
1015 | public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { | ||
1016 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1017 | result.submessers_[index] = value; | ||
1018 | return this; | ||
1019 | } | ||
1020 | public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) { | ||
1021 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
1022 | result.submessers_[index] = builderForValue.Build(); | ||
1023 | return this; | ||
1024 | } | ||
1025 | public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) { | ||
1026 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1027 | result.submessers_.Add(value); | ||
1028 | return this; | ||
1029 | } | ||
1030 | public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) { | ||
1031 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
1032 | result.submessers_.Add(builderForValue.Build()); | ||
1033 | return this; | ||
1034 | } | ||
1035 | public Builder AddRangeSubmessers(scg::IEnumerable<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> values) { | ||
1036 | base.AddRange(values, result.submessers_); | ||
1037 | return this; | ||
1038 | } | ||
1039 | public Builder ClearSubmessers() { | ||
1040 | result.submessers_.Clear(); | ||
1041 | return this; | ||
1042 | } | ||
1043 | |||
1044 | public bool HasSha { | ||
1045 | get { return result.HasSha; } | ||
1046 | } | ||
1047 | public pb::ByteString Sha { | ||
1048 | get { return result.Sha; } | ||
1049 | set { SetSha(value); } | ||
1050 | } | ||
1051 | public Builder SetSha(pb::ByteString value) { | ||
1052 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1053 | result.hasSha = true; | ||
1054 | result.sha_ = value; | ||
1055 | return this; | ||
1056 | } | ||
1057 | public Builder ClearSha() { | ||
1058 | result.hasSha = false; | ||
1059 | result.sha_ = pb::ByteString.Empty; | ||
1060 | return this; | ||
1061 | } | ||
1062 | |||
1063 | public pbc::IPopsicleList<pb::ByteString> ShasList { | ||
1064 | get { return result.shas_; } | ||
1065 | } | ||
1066 | public int ShasCount { | ||
1067 | get { return result.ShasCount; } | ||
1068 | } | ||
1069 | public pb::ByteString GetShas(int index) { | ||
1070 | return result.GetShas(index); | ||
1071 | } | ||
1072 | public Builder SetShas(int index, pb::ByteString value) { | ||
1073 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1074 | result.shas_[index] = value; | ||
1075 | return this; | ||
1076 | } | ||
1077 | public Builder AddShas(pb::ByteString value) { | ||
1078 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1079 | result.shas_.Add(value); | ||
1080 | return this; | ||
1081 | } | ||
1082 | public Builder AddRangeShas(scg::IEnumerable<pb::ByteString> values) { | ||
1083 | base.AddRange(values, result.shas_); | ||
1084 | return this; | ||
1085 | } | ||
1086 | public Builder ClearShas() { | ||
1087 | result.shas_.Clear(); | ||
1088 | return this; | ||
1089 | } | ||
1090 | |||
1091 | public pbc::IPopsicleList<float> V3FList { | ||
1092 | get { return result.v3F_; } | ||
1093 | } | ||
1094 | public int V3FCount { | ||
1095 | get { return result.V3FCount; } | ||
1096 | } | ||
1097 | public float GetV3F(int index) { | ||
1098 | return result.GetV3F(index); | ||
1099 | } | ||
1100 | public Builder SetV3F(int index, float value) { | ||
1101 | result.v3F_[index] = value; | ||
1102 | return this; | ||
1103 | } | ||
1104 | public Builder AddV3F(float value) { | ||
1105 | result.v3F_.Add(value); | ||
1106 | return this; | ||
1107 | } | ||
1108 | public Builder AddRangeV3F(scg::IEnumerable<float> values) { | ||
1109 | base.AddRange(values, result.v3F_); | ||
1110 | return this; | ||
1111 | } | ||
1112 | public Builder ClearV3F() { | ||
1113 | result.v3F_.Clear(); | ||
1114 | return this; | ||
1115 | } | ||
1116 | |||
1117 | public pbc::IPopsicleList<float> V3FfList { | ||
1118 | get { return result.v3Ff_; } | ||
1119 | } | ||
1120 | public int V3FfCount { | ||
1121 | get { return result.V3FfCount; } | ||
1122 | } | ||
1123 | public float GetV3Ff(int index) { | ||
1124 | return result.GetV3Ff(index); | ||
1125 | } | ||
1126 | public Builder SetV3Ff(int index, float value) { | ||
1127 | result.v3Ff_[index] = value; | ||
1128 | return this; | ||
1129 | } | ||
1130 | public Builder AddV3Ff(float value) { | ||
1131 | result.v3Ff_.Add(value); | ||
1132 | return this; | ||
1133 | } | ||
1134 | public Builder AddRangeV3Ff(scg::IEnumerable<float> values) { | ||
1135 | base.AddRange(values, result.v3Ff_); | ||
1136 | return this; | ||
1137 | } | ||
1138 | public Builder ClearV3Ff() { | ||
1139 | result.v3Ff_.Clear(); | ||
1140 | return this; | ||
1141 | } | ||
1142 | } | ||
1143 | static ExternalMessage() { | ||
1144 | object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); | ||
1145 | } | ||
1146 | } | ||
1147 | |||
1148 | public sealed partial class TestMessage : pb::ExtendableMessage<TestMessage, TestMessage.Builder> { | ||
1149 | private static readonly TestMessage defaultInstance = new Builder().BuildPartial(); | ||
1150 | public static TestMessage DefaultInstance { | ||
1151 | get { return defaultInstance; } | ||
1152 | } | ||
1153 | |||
1154 | public override TestMessage DefaultInstanceForType { | ||
1155 | get { return defaultInstance; } | ||
1156 | } | ||
1157 | |||
1158 | protected override TestMessage ThisMessage { | ||
1159 | get { return this; } | ||
1160 | } | ||
1161 | |||
1162 | public static pbd::MessageDescriptor Descriptor { | ||
1163 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor; } | ||
1164 | } | ||
1165 | |||
1166 | protected override pb::FieldAccess.FieldAccessorTable<TestMessage, TestMessage.Builder> InternalFieldAccessors { | ||
1167 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable; } | ||
1168 | } | ||
1169 | |||
1170 | #region Nested types | ||
1171 | public static class Types { | ||
1172 | public enum Flagsf32 { | ||
1173 | UNIVERSA = 0, | ||
1174 | WE = 1, | ||
1175 | IMAGE = 2, | ||
1176 | LOCA = 3, | ||
1177 | } | ||
1178 | |||
1179 | public enum Flagsf64 { | ||
1180 | UNIVERSAL = 0, | ||
1181 | WEB = 1, | ||
1182 | IMAGES = 2, | ||
1183 | LOCAL = 3, | ||
1184 | } | ||
1185 | |||
1186 | public enum Enum32 { | ||
1187 | UNIVERSAL1 = 0, | ||
1188 | WEB1 = 1, | ||
1189 | IMAGES1 = 2, | ||
1190 | LOCAL1 = 3, | ||
1191 | } | ||
1192 | |||
1193 | public sealed partial class SubMessage : pb::GeneratedMessage<SubMessage, SubMessage.Builder> { | ||
1194 | private static readonly SubMessage defaultInstance = new Builder().BuildPartial(); | ||
1195 | public static SubMessage DefaultInstance { | ||
1196 | get { return defaultInstance; } | ||
1197 | } | ||
1198 | |||
1199 | public override SubMessage DefaultInstanceForType { | ||
1200 | get { return defaultInstance; } | ||
1201 | } | ||
1202 | |||
1203 | protected override SubMessage ThisMessage { | ||
1204 | get { return this; } | ||
1205 | } | ||
1206 | |||
1207 | public static pbd::MessageDescriptor Descriptor { | ||
1208 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor; } | ||
1209 | } | ||
1210 | |||
1211 | protected override pb::FieldAccess.FieldAccessorTable<SubMessage, SubMessage.Builder> InternalFieldAccessors { | ||
1212 | get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable; } | ||
1213 | } | ||
1214 | |||
1215 | public const int SubuuidFieldNumber = 1; | ||
1216 | private bool hasSubuuid; | ||
1217 | private pb::ByteString subuuid_ = pb::ByteString.Empty; | ||
1218 | public bool HasSubuuid { | ||
1219 | get { return hasSubuuid; } | ||
1220 | } | ||
1221 | public pb::ByteString Subuuid { | ||
1222 | get { return subuuid_; } | ||
1223 | } | ||
1224 | |||
1225 | public const int SubvectorFieldNumber = 2; | ||
1226 | private int subvectorMemoizedSerializedSize; | ||
1227 | private pbc::PopsicleList<double> subvector_ = new pbc::PopsicleList<double>(); | ||
1228 | public scg::IList<double> SubvectorList { | ||
1229 | get { return pbc::Lists.AsReadOnly(subvector_); } | ||
1230 | } | ||
1231 | public int SubvectorCount { | ||
1232 | get { return subvector_.Count; } | ||
1233 | } | ||
1234 | public double GetSubvector(int index) { | ||
1235 | return subvector_[index]; | ||
1236 | } | ||
1237 | |||
1238 | public const int SubdurationFieldNumber = 3; | ||
1239 | private bool hasSubduration; | ||
1240 | private long subduration_ = 0; | ||
1241 | public bool HasSubduration { | ||
1242 | get { return hasSubduration; } | ||
1243 | } | ||
1244 | public long Subduration { | ||
1245 | get { return subduration_; } | ||
1246 | } | ||
1247 | |||
1248 | public const int SubnormalFieldNumber = 4; | ||
1249 | private int subnormalMemoizedSerializedSize; | ||
1250 | private pbc::PopsicleList<float> subnormal_ = new pbc::PopsicleList<float>(); | ||
1251 | public scg::IList<float> SubnormalList { | ||
1252 | get { return pbc::Lists.AsReadOnly(subnormal_); } | ||
1253 | } | ||
1254 | public int SubnormalCount { | ||
1255 | get { return subnormal_.Count; } | ||
1256 | } | ||
1257 | public float GetSubnormal(int index) { | ||
1258 | return subnormal_[index]; | ||
1259 | } | ||
1260 | |||
1261 | public override bool IsInitialized { | ||
1262 | get { | ||
1263 | return true; | ||
1264 | } | ||
1265 | } | ||
1266 | |||
1267 | public override void WriteTo(pb::CodedOutputStream output) { | ||
1268 | if (HasSubuuid) { | ||
1269 | output.WriteBytes(1, Subuuid); | ||
1270 | } | ||
1271 | if (subvector_.Count > 0) { | ||
1272 | output.WriteRawVarint32(18); | ||
1273 | output.WriteRawVarint32((uint) subvectorMemoizedSerializedSize); | ||
1274 | foreach (double element in subvector_) { | ||
1275 | output.WriteDoubleNoTag(element); | ||
1276 | } | ||
1277 | } | ||
1278 | if (HasSubduration) { | ||
1279 | output.WriteSFixed64(3, Subduration); | ||
1280 | } | ||
1281 | if (subnormal_.Count > 0) { | ||
1282 | output.WriteRawVarint32(34); | ||
1283 | output.WriteRawVarint32((uint) subnormalMemoizedSerializedSize); | ||
1284 | foreach (float element in subnormal_) { | ||
1285 | output.WriteFloatNoTag(element); | ||
1286 | } | ||
1287 | } | ||
1288 | UnknownFields.WriteTo(output); | ||
1289 | } | ||
1290 | |||
1291 | private int memoizedSerializedSize = -1; | ||
1292 | public override int SerializedSize { | ||
1293 | get { | ||
1294 | int size = memoizedSerializedSize; | ||
1295 | if (size != -1) return size; | ||
1296 | |||
1297 | size = 0; | ||
1298 | if (HasSubuuid) { | ||
1299 | size += pb::CodedOutputStream.ComputeBytesSize(1, Subuuid); | ||
1300 | } | ||
1301 | { | ||
1302 | int dataSize = 0; | ||
1303 | dataSize = 8 * subvector_.Count; | ||
1304 | size += dataSize; | ||
1305 | if (subvector_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
1306 | subvectorMemoizedSerializedSize = dataSize; | ||
1307 | } | ||
1308 | if (HasSubduration) { | ||
1309 | size += pb::CodedOutputStream.ComputeSFixed64Size(3, Subduration); | ||
1310 | } | ||
1311 | { | ||
1312 | int dataSize = 0; | ||
1313 | dataSize = 4 * subnormal_.Count; | ||
1314 | size += dataSize; | ||
1315 | if (subnormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
1316 | subnormalMemoizedSerializedSize = dataSize; | ||
1317 | } | ||
1318 | size += UnknownFields.SerializedSize; | ||
1319 | memoizedSerializedSize = size; | ||
1320 | return size; | ||
1321 | } | ||
1322 | } | ||
1323 | |||
1324 | public static SubMessage ParseFrom(pb::ByteString data) { | ||
1325 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1326 | } | ||
1327 | public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
1328 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1329 | } | ||
1330 | public static SubMessage ParseFrom(byte[] data) { | ||
1331 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
1332 | } | ||
1333 | public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
1334 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
1335 | } | ||
1336 | public static SubMessage ParseFrom(global::System.IO.Stream input) { | ||
1337 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1338 | } | ||
1339 | public static SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1340 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1341 | } | ||
1342 | public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input) { | ||
1343 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
1344 | } | ||
1345 | public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
1346 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
1347 | } | ||
1348 | public static SubMessage ParseFrom(pb::CodedInputStream input) { | ||
1349 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
1350 | } | ||
1351 | public static SubMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1352 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
1353 | } | ||
1354 | public static Builder CreateBuilder() { return new Builder(); } | ||
1355 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
1356 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
1357 | public static Builder CreateBuilder(SubMessage prototype) { | ||
1358 | return (Builder) new Builder().MergeFrom(prototype); | ||
1359 | } | ||
1360 | |||
1361 | public sealed partial class Builder : pb::GeneratedBuilder<SubMessage, Builder> { | ||
1362 | protected override Builder ThisBuilder { | ||
1363 | get { return this; } | ||
1364 | } | ||
1365 | public Builder() {} | ||
1366 | |||
1367 | SubMessage result = new SubMessage(); | ||
1368 | |||
1369 | protected override SubMessage MessageBeingBuilt { | ||
1370 | get { return result; } | ||
1371 | } | ||
1372 | |||
1373 | public override Builder Clear() { | ||
1374 | result = new SubMessage(); | ||
1375 | return this; | ||
1376 | } | ||
1377 | |||
1378 | public override Builder Clone() { | ||
1379 | return new Builder().MergeFrom(result); | ||
1380 | } | ||
1381 | |||
1382 | public override pbd::MessageDescriptor DescriptorForType { | ||
1383 | get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Descriptor; } | ||
1384 | } | ||
1385 | |||
1386 | public override SubMessage DefaultInstanceForType { | ||
1387 | get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance; } | ||
1388 | } | ||
1389 | |||
1390 | public override SubMessage BuildPartial() { | ||
1391 | if (result == null) { | ||
1392 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
1393 | } | ||
1394 | result.subvector_.MakeReadOnly(); | ||
1395 | result.subnormal_.MakeReadOnly(); | ||
1396 | SubMessage returnMe = result; | ||
1397 | result = null; | ||
1398 | return returnMe; | ||
1399 | } | ||
1400 | |||
1401 | public override Builder MergeFrom(pb::IMessage other) { | ||
1402 | if (other is SubMessage) { | ||
1403 | return MergeFrom((SubMessage) other); | ||
1404 | } else { | ||
1405 | base.MergeFrom(other); | ||
1406 | return this; | ||
1407 | } | ||
1408 | } | ||
1409 | |||
1410 | public override Builder MergeFrom(SubMessage other) { | ||
1411 | if (other == global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance) return this; | ||
1412 | if (other.HasSubuuid) { | ||
1413 | Subuuid = other.Subuuid; | ||
1414 | } | ||
1415 | if (other.subvector_.Count != 0) { | ||
1416 | base.AddRange(other.subvector_, result.subvector_); | ||
1417 | } | ||
1418 | if (other.HasSubduration) { | ||
1419 | Subduration = other.Subduration; | ||
1420 | } | ||
1421 | if (other.subnormal_.Count != 0) { | ||
1422 | base.AddRange(other.subnormal_, result.subnormal_); | ||
1423 | } | ||
1424 | this.MergeUnknownFields(other.UnknownFields); | ||
1425 | return this; | ||
1426 | } | ||
1427 | |||
1428 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
1429 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
1430 | } | ||
1431 | |||
1432 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
1433 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
1434 | while (true) { | ||
1435 | uint tag = input.ReadTag(); | ||
1436 | switch (tag) { | ||
1437 | case 0: { | ||
1438 | if (unknownFields != null) { | ||
1439 | this.UnknownFields = unknownFields.Build(); | ||
1440 | } | ||
1441 | return this; | ||
1442 | } | ||
1443 | default: { | ||
1444 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
1445 | if (unknownFields != null) { | ||
1446 | this.UnknownFields = unknownFields.Build(); | ||
1447 | } | ||
1448 | return this; | ||
1449 | } | ||
1450 | if (unknownFields == null) { | ||
1451 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
1452 | } | ||
1453 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
1454 | break; | ||
1455 | } | ||
1456 | case 10: { | ||
1457 | Subuuid = input.ReadBytes(); | ||
1458 | break; | ||
1459 | } | ||
1460 | case 18: { | ||
1461 | int length = input.ReadInt32(); | ||
1462 | int limit = input.PushLimit(length); | ||
1463 | while (!input.ReachedLimit) { | ||
1464 | AddSubvector(input.ReadDouble()); | ||
1465 | } | ||
1466 | input.PopLimit(limit); | ||
1467 | break; | ||
1468 | } | ||
1469 | case 25: { | ||
1470 | Subduration = input.ReadSFixed64(); | ||
1471 | break; | ||
1472 | } | ||
1473 | case 34: { | ||
1474 | int length = input.ReadInt32(); | ||
1475 | int limit = input.PushLimit(length); | ||
1476 | while (!input.ReachedLimit) { | ||
1477 | AddSubnormal(input.ReadFloat()); | ||
1478 | } | ||
1479 | input.PopLimit(limit); | ||
1480 | break; | ||
1481 | } | ||
1482 | } | ||
1483 | } | ||
1484 | } | ||
1485 | |||
1486 | |||
1487 | public bool HasSubuuid { | ||
1488 | get { return result.HasSubuuid; } | ||
1489 | } | ||
1490 | public pb::ByteString Subuuid { | ||
1491 | get { return result.Subuuid; } | ||
1492 | set { SetSubuuid(value); } | ||
1493 | } | ||
1494 | public Builder SetSubuuid(pb::ByteString value) { | ||
1495 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
1496 | result.hasSubuuid = true; | ||
1497 | result.subuuid_ = value; | ||
1498 | return this; | ||
1499 | } | ||
1500 | public Builder ClearSubuuid() { | ||
1501 | result.hasSubuuid = false; | ||
1502 | result.subuuid_ = pb::ByteString.Empty; | ||
1503 | return this; | ||
1504 | } | ||
1505 | |||
1506 | public pbc::IPopsicleList<double> SubvectorList { | ||
1507 | get { return result.subvector_; } | ||
1508 | } | ||
1509 | public int SubvectorCount { | ||
1510 | get { return result.SubvectorCount; } | ||
1511 | } | ||
1512 | public double GetSubvector(int index) { | ||
1513 | return result.GetSubvector(index); | ||
1514 | } | ||
1515 | public Builder SetSubvector(int index, double value) { | ||
1516 | result.subvector_[index] = value; | ||
1517 | return this; | ||
1518 | } | ||
1519 | public Builder AddSubvector(double value) { | ||
1520 | result.subvector_.Add(value); | ||
1521 | return this; | ||
1522 | } | ||
1523 | public Builder AddRangeSubvector(scg::IEnumerable<double> values) { | ||
1524 | base.AddRange(values, result.subvector_); | ||
1525 | return this; | ||
1526 | } | ||
1527 | public Builder ClearSubvector() { | ||
1528 | result.subvector_.Clear(); | ||
1529 | return this; | ||
1530 | } | ||
1531 | |||
1532 | public bool HasSubduration { | ||
1533 | get { return result.HasSubduration; } | ||
1534 | } | ||
1535 | public long Subduration { | ||
1536 | get { return result.Subduration; } | ||
1537 | set { SetSubduration(value); } | ||
1538 | } | ||
1539 | public Builder SetSubduration(long value) { | ||
1540 | result.hasSubduration = true; | ||
1541 | result.subduration_ = value; | ||
1542 | return this; | ||
1543 | } | ||
1544 | public Builder ClearSubduration() { | ||
1545 | result.hasSubduration = false; | ||
1546 | result.subduration_ = 0; | ||
1547 | return this; | ||
1548 | } | ||
1549 | |||
1550 | public pbc::IPopsicleList<float> SubnormalList { | ||
1551 | get { return result.subnormal_; } | ||
1552 | } | ||
1553 | public int SubnormalCount { | ||
1554 | get { return result.SubnormalCount; } | ||
1555 | } | ||
1556 | public float GetSubnormal(int index) { | ||
1557 | return result.GetSubnormal(index); | ||
1558 | } | ||
1559 | public Builder SetSubnormal(int index, float value) { | ||
1560 | result.subnormal_[index] = value; | ||
1561 | return this; | ||
1562 | } | ||
1563 | public Builder AddSubnormal(float value) { | ||
1564 | result.subnormal_.Add(value); | ||
1565 | return this; | ||
1566 | } | ||
1567 | public Builder AddRangeSubnormal(scg::IEnumerable<float> values) { | ||
1568 | base.AddRange(values, result.subnormal_); | ||
1569 | return this; | ||
1570 | } | ||
1571 | public Builder ClearSubnormal() { | ||
1572 | result.subnormal_.Clear(); | ||
1573 | return this; | ||
1574 | } | ||
1575 | } | ||
1576 | static SubMessage() { | ||
1577 | object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); | ||
1578 | } | ||
1579 | } | ||
1580 | |||
1581 | } | ||
1582 | #endregion | ||
1583 | |||
1584 | public const int XxdFieldNumber = 20; | ||
1585 | private bool hasXxd; | ||
1586 | private double xxd_ = 10.3D; | ||
1587 | public bool HasXxd { | ||
1588 | get { return hasXxd; } | ||
1589 | } | ||
1590 | public double Xxd { | ||
1591 | get { return xxd_; } | ||
1592 | } | ||
1593 | |||
1594 | public const int XxfFieldNumber = 21; | ||
1595 | private bool hasXxf; | ||
1596 | private float xxf_ = 0F; | ||
1597 | public bool HasXxf { | ||
1598 | get { return hasXxf; } | ||
1599 | } | ||
1600 | public float Xxf { | ||
1601 | get { return xxf_; } | ||
1602 | } | ||
1603 | |||
1604 | public const int Xxu32FieldNumber = 22; | ||
1605 | private bool hasXxu32; | ||
1606 | private uint xxu32_ = 0; | ||
1607 | public bool HasXxu32 { | ||
1608 | get { return hasXxu32; } | ||
1609 | } | ||
1610 | [global::System.CLSCompliant(false)] | ||
1611 | public uint Xxu32 { | ||
1612 | get { return xxu32_; } | ||
1613 | } | ||
1614 | |||
1615 | public const int XxsFieldNumber = 23; | ||
1616 | private bool hasXxs; | ||
1617 | private string xxs_ = ""; | ||
1618 | public bool HasXxs { | ||
1619 | get { return hasXxs; } | ||
1620 | } | ||
1621 | public string Xxs { | ||
1622 | get { return xxs_; } | ||
1623 | } | ||
1624 | |||
1625 | public const int XxbFieldNumber = 24; | ||
1626 | private bool hasXxb; | ||
1627 | private pb::ByteString xxb_ = pb::ByteString.Empty; | ||
1628 | public bool HasXxb { | ||
1629 | get { return hasXxb; } | ||
1630 | } | ||
1631 | public pb::ByteString Xxb { | ||
1632 | get { return xxb_; } | ||
1633 | } | ||
1634 | |||
1635 | public const int XxssFieldNumber = 25; | ||
1636 | private pbc::PopsicleList<string> xxss_ = new pbc::PopsicleList<string>(); | ||
1637 | public scg::IList<string> XxssList { | ||
1638 | get { return pbc::Lists.AsReadOnly(xxss_); } | ||
1639 | } | ||
1640 | public int XxssCount { | ||
1641 | get { return xxss_.Count; } | ||
1642 | } | ||
1643 | public string GetXxss(int index) { | ||
1644 | return xxss_[index]; | ||
1645 | } | ||
1646 | |||
1647 | public const int XxbbFieldNumber = 26; | ||
1648 | private pbc::PopsicleList<pb::ByteString> xxbb_ = new pbc::PopsicleList<pb::ByteString>(); | ||
1649 | public scg::IList<pb::ByteString> XxbbList { | ||
1650 | get { return pbc::Lists.AsReadOnly(xxbb_); } | ||
1651 | } | ||
1652 | public int XxbbCount { | ||
1653 | get { return xxbb_.Count; } | ||
1654 | } | ||
1655 | public pb::ByteString GetXxbb(int index) { | ||
1656 | return xxbb_[index]; | ||
1657 | } | ||
1658 | |||
1659 | public const int XxffFieldNumber = 27; | ||
1660 | private int xxffMemoizedSerializedSize; | ||
1661 | private pbc::PopsicleList<float> xxff_ = new pbc::PopsicleList<float>(); | ||
1662 | public scg::IList<float> XxffList { | ||
1663 | get { return pbc::Lists.AsReadOnly(xxff_); } | ||
1664 | } | ||
1665 | public int XxffCount { | ||
1666 | get { return xxff_.Count; } | ||
1667 | } | ||
1668 | public float GetXxff(int index) { | ||
1669 | return xxff_[index]; | ||
1670 | } | ||
1671 | |||
1672 | public const int XxnnFieldNumber = 29; | ||
1673 | private int xxnnMemoizedSerializedSize; | ||
1674 | private pbc::PopsicleList<float> xxnn_ = new pbc::PopsicleList<float>(); | ||
1675 | public scg::IList<float> XxnnList { | ||
1676 | get { return pbc::Lists.AsReadOnly(xxnn_); } | ||
1677 | } | ||
1678 | public int XxnnCount { | ||
1679 | get { return xxnn_.Count; } | ||
1680 | } | ||
1681 | public float GetXxnn(int index) { | ||
1682 | return xxnn_[index]; | ||
1683 | } | ||
1684 | |||
1685 | public const int XxfrFieldNumber = 28; | ||
1686 | private bool hasXxfr; | ||
1687 | private float xxfr_ = 0F; | ||
1688 | public bool HasXxfr { | ||
1689 | get { return hasXxfr; } | ||
1690 | } | ||
1691 | public float Xxfr { | ||
1692 | get { return xxfr_; } | ||
1693 | } | ||
1694 | |||
1695 | public const int NFieldNumber = 1; | ||
1696 | private int nMemoizedSerializedSize; | ||
1697 | private pbc::PopsicleList<float> n_ = new pbc::PopsicleList<float>(); | ||
1698 | public scg::IList<float> NList { | ||
1699 | get { return pbc::Lists.AsReadOnly(n_); } | ||
1700 | } | ||
1701 | public int NCount { | ||
1702 | get { return n_.Count; } | ||
1703 | } | ||
1704 | public float GetN(int index) { | ||
1705 | return n_[index]; | ||
1706 | } | ||
1707 | |||
1708 | public const int V2FFieldNumber = 2; | ||
1709 | private int v2FMemoizedSerializedSize; | ||
1710 | private pbc::PopsicleList<float> v2F_ = new pbc::PopsicleList<float>(); | ||
1711 | public scg::IList<float> V2FList { | ||
1712 | get { return pbc::Lists.AsReadOnly(v2F_); } | ||
1713 | } | ||
1714 | public int V2FCount { | ||
1715 | get { return v2F_.Count; } | ||
1716 | } | ||
1717 | public float GetV2F(int index) { | ||
1718 | return v2F_[index]; | ||
1719 | } | ||
1720 | |||
1721 | public const int V2DFieldNumber = 3; | ||
1722 | private int v2DMemoizedSerializedSize; | ||
1723 | private pbc::PopsicleList<double> v2D_ = new pbc::PopsicleList<double>(); | ||
1724 | public scg::IList<double> V2DList { | ||
1725 | get { return pbc::Lists.AsReadOnly(v2D_); } | ||
1726 | } | ||
1727 | public int V2DCount { | ||
1728 | get { return v2D_.Count; } | ||
1729 | } | ||
1730 | public double GetV2D(int index) { | ||
1731 | return v2D_[index]; | ||
1732 | } | ||
1733 | |||
1734 | public const int V3FFieldNumber = 4; | ||
1735 | private int v3FMemoizedSerializedSize; | ||
1736 | private pbc::PopsicleList<float> v3F_ = new pbc::PopsicleList<float>(); | ||
1737 | public scg::IList<float> V3FList { | ||
1738 | get { return pbc::Lists.AsReadOnly(v3F_); } | ||
1739 | } | ||
1740 | public int V3FCount { | ||
1741 | get { return v3F_.Count; } | ||
1742 | } | ||
1743 | public float GetV3F(int index) { | ||
1744 | return v3F_[index]; | ||
1745 | } | ||
1746 | |||
1747 | public const int V3DFieldNumber = 5; | ||
1748 | private int v3DMemoizedSerializedSize; | ||
1749 | private pbc::PopsicleList<double> v3D_ = new pbc::PopsicleList<double>(); | ||
1750 | public scg::IList<double> V3DList { | ||
1751 | get { return pbc::Lists.AsReadOnly(v3D_); } | ||
1752 | } | ||
1753 | public int V3DCount { | ||
1754 | get { return v3D_.Count; } | ||
1755 | } | ||
1756 | public double GetV3D(int index) { | ||
1757 | return v3D_[index]; | ||
1758 | } | ||
1759 | |||
1760 | public const int V4FFieldNumber = 6; | ||
1761 | private int v4FMemoizedSerializedSize; | ||
1762 | private pbc::PopsicleList<float> v4F_ = new pbc::PopsicleList<float>(); | ||
1763 | public scg::IList<float> V4FList { | ||
1764 | get { return pbc::Lists.AsReadOnly(v4F_); } | ||
1765 | } | ||
1766 | public int V4FCount { | ||
1767 | get { return v4F_.Count; } | ||
1768 | } | ||
1769 | public float GetV4F(int index) { | ||
1770 | return v4F_[index]; | ||
1771 | } | ||
1772 | |||
1773 | public const int V4DFieldNumber = 7; | ||
1774 | private int v4DMemoizedSerializedSize; | ||
1775 | private pbc::PopsicleList<double> v4D_ = new pbc::PopsicleList<double>(); | ||
1776 | public scg::IList<double> V4DList { | ||
1777 | get { return pbc::Lists.AsReadOnly(v4D_); } | ||
1778 | } | ||
1779 | public int V4DCount { | ||
1780 | get { return v4D_.Count; } | ||
1781 | } | ||
1782 | public double GetV4D(int index) { | ||
1783 | return v4D_[index]; | ||
1784 | } | ||
1785 | |||
1786 | public const int QFieldNumber = 8; | ||
1787 | private int qMemoizedSerializedSize; | ||
1788 | private pbc::PopsicleList<float> q_ = new pbc::PopsicleList<float>(); | ||
1789 | public scg::IList<float> QList { | ||
1790 | get { return pbc::Lists.AsReadOnly(q_); } | ||
1791 | } | ||
1792 | public int QCount { | ||
1793 | get { return q_.Count; } | ||
1794 | } | ||
1795 | public float GetQ(int index) { | ||
1796 | return q_[index]; | ||
1797 | } | ||
1798 | |||
1799 | public const int UFieldNumber = 9; | ||
1800 | private bool hasU; | ||
1801 | private pb::ByteString u_ = pb::ByteString.Empty; | ||
1802 | public bool HasU { | ||
1803 | get { return hasU; } | ||
1804 | } | ||
1805 | public pb::ByteString U { | ||
1806 | get { return u_; } | ||
1807 | } | ||
1808 | |||
1809 | public const int AFieldNumber = 10; | ||
1810 | private bool hasA; | ||
1811 | private float a_ = 0F; | ||
1812 | public bool HasA { | ||
1813 | get { return hasA; } | ||
1814 | } | ||
1815 | public float A { | ||
1816 | get { return a_; } | ||
1817 | } | ||
1818 | |||
1819 | public const int TFieldNumber = 11; | ||
1820 | private bool hasT; | ||
1821 | private ulong t_ = 0; | ||
1822 | public bool HasT { | ||
1823 | get { return hasT; } | ||
1824 | } | ||
1825 | [global::System.CLSCompliant(false)] | ||
1826 | public ulong T { | ||
1827 | get { return t_; } | ||
1828 | } | ||
1829 | |||
1830 | public const int DFieldNumber = 12; | ||
1831 | private bool hasD; | ||
1832 | private long d_ = 0; | ||
1833 | public bool HasD { | ||
1834 | get { return hasD; } | ||
1835 | } | ||
1836 | public long D { | ||
1837 | get { return d_; } | ||
1838 | } | ||
1839 | |||
1840 | public const int F32FieldNumber = 13; | ||
1841 | private bool hasF32; | ||
1842 | private uint f32_ = 0; | ||
1843 | public bool HasF32 { | ||
1844 | get { return hasF32; } | ||
1845 | } | ||
1846 | [global::System.CLSCompliant(false)] | ||
1847 | public uint F32 { | ||
1848 | get { return f32_; } | ||
1849 | } | ||
1850 | |||
1851 | public const int F64FieldNumber = 14; | ||
1852 | private bool hasF64; | ||
1853 | private ulong f64_ = 0UL; | ||
1854 | public bool HasF64 { | ||
1855 | get { return hasF64; } | ||
1856 | } | ||
1857 | [global::System.CLSCompliant(false)] | ||
1858 | public ulong F64 { | ||
1859 | get { return f64_; } | ||
1860 | } | ||
1861 | |||
1862 | public const int BsfFieldNumber = 15; | ||
1863 | private int bsfMemoizedSerializedSize; | ||
1864 | private pbc::PopsicleList<float> bsf_ = new pbc::PopsicleList<float>(); | ||
1865 | public scg::IList<float> BsfList { | ||
1866 | get { return pbc::Lists.AsReadOnly(bsf_); } | ||
1867 | } | ||
1868 | public int BsfCount { | ||
1869 | get { return bsf_.Count; } | ||
1870 | } | ||
1871 | public float GetBsf(int index) { | ||
1872 | return bsf_[index]; | ||
1873 | } | ||
1874 | |||
1875 | public const int BsdFieldNumber = 16; | ||
1876 | private int bsdMemoizedSerializedSize; | ||
1877 | private pbc::PopsicleList<double> bsd_ = new pbc::PopsicleList<double>(); | ||
1878 | public scg::IList<double> BsdList { | ||
1879 | get { return pbc::Lists.AsReadOnly(bsd_); } | ||
1880 | } | ||
1881 | public int BsdCount { | ||
1882 | get { return bsd_.Count; } | ||
1883 | } | ||
1884 | public double GetBsd(int index) { | ||
1885 | return bsd_[index]; | ||
1886 | } | ||
1887 | |||
1888 | public const int BbfFieldNumber = 17; | ||
1889 | private int bbfMemoizedSerializedSize; | ||
1890 | private pbc::PopsicleList<float> bbf_ = new pbc::PopsicleList<float>(); | ||
1891 | public scg::IList<float> BbfList { | ||
1892 | get { return pbc::Lists.AsReadOnly(bbf_); } | ||
1893 | } | ||
1894 | public int BbfCount { | ||
1895 | get { return bbf_.Count; } | ||
1896 | } | ||
1897 | public float GetBbf(int index) { | ||
1898 | return bbf_[index]; | ||
1899 | } | ||
1900 | |||
1901 | public const int BbdFieldNumber = 18; | ||
1902 | private int bbdMemoizedSerializedSize; | ||
1903 | private pbc::PopsicleList<double> bbd_ = new pbc::PopsicleList<double>(); | ||
1904 | public scg::IList<double> BbdList { | ||
1905 | get { return pbc::Lists.AsReadOnly(bbd_); } | ||
1906 | } | ||
1907 | public int BbdCount { | ||
1908 | get { return bbd_.Count; } | ||
1909 | } | ||
1910 | public double GetBbd(int index) { | ||
1911 | return bbd_[index]; | ||
1912 | } | ||
1913 | |||
1914 | public const int E32FieldNumber = 19; | ||
1915 | private bool hasE32; | ||
1916 | private global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 e32_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1; | ||
1917 | public bool HasE32 { | ||
1918 | get { return hasE32; } | ||
1919 | } | ||
1920 | public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 E32 { | ||
1921 | get { return e32_; } | ||
1922 | } | ||
1923 | |||
1924 | public const int SubmesFieldNumber = 30; | ||
1925 | private bool hasSubmes; | ||
1926 | private global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance; | ||
1927 | public bool HasSubmes { | ||
1928 | get { return hasSubmes; } | ||
1929 | } | ||
1930 | public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage Submes { | ||
1931 | get { return submes_; } | ||
1932 | } | ||
1933 | |||
1934 | public const int SubmessersFieldNumber = 31; | ||
1935 | private pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> submessers_ = new pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage>(); | ||
1936 | public scg::IList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> SubmessersList { | ||
1937 | get { return submessers_; } | ||
1938 | } | ||
1939 | public int SubmessersCount { | ||
1940 | get { return submessers_.Count; } | ||
1941 | } | ||
1942 | public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage GetSubmessers(int index) { | ||
1943 | return submessers_[index]; | ||
1944 | } | ||
1945 | |||
1946 | public const int ShaFieldNumber = 32; | ||
1947 | private bool hasSha; | ||
1948 | private pb::ByteString sha_ = pb::ByteString.Empty; | ||
1949 | public bool HasSha { | ||
1950 | get { return hasSha; } | ||
1951 | } | ||
1952 | public pb::ByteString Sha { | ||
1953 | get { return sha_; } | ||
1954 | } | ||
1955 | |||
1956 | public const int ShasFieldNumber = 33; | ||
1957 | private pbc::PopsicleList<pb::ByteString> shas_ = new pbc::PopsicleList<pb::ByteString>(); | ||
1958 | public scg::IList<pb::ByteString> ShasList { | ||
1959 | get { return pbc::Lists.AsReadOnly(shas_); } | ||
1960 | } | ||
1961 | public int ShasCount { | ||
1962 | get { return shas_.Count; } | ||
1963 | } | ||
1964 | public pb::ByteString GetShas(int index) { | ||
1965 | return shas_[index]; | ||
1966 | } | ||
1967 | |||
1968 | public const int ExtmesFieldNumber = 34; | ||
1969 | private bool hasExtmes; | ||
1970 | private global::Sirikata.PB._PBJ_Internal.ExternalMessage extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; | ||
1971 | public bool HasExtmes { | ||
1972 | get { return hasExtmes; } | ||
1973 | } | ||
1974 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmes { | ||
1975 | get { return extmes_; } | ||
1976 | } | ||
1977 | |||
1978 | public const int ExtmessersFieldNumber = 35; | ||
1979 | private pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage> extmessers_ = new pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage>(); | ||
1980 | public scg::IList<global::Sirikata.PB._PBJ_Internal.ExternalMessage> ExtmessersList { | ||
1981 | get { return extmessers_; } | ||
1982 | } | ||
1983 | public int ExtmessersCount { | ||
1984 | get { return extmessers_.Count; } | ||
1985 | } | ||
1986 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage GetExtmessers(int index) { | ||
1987 | return extmessers_[index]; | ||
1988 | } | ||
1989 | |||
1990 | public const int ExtmesserFieldNumber = 36; | ||
1991 | private bool hasExtmesser; | ||
1992 | private global::Sirikata.PB._PBJ_Internal.ExternalMessage extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; | ||
1993 | public bool HasExtmesser { | ||
1994 | get { return hasExtmesser; } | ||
1995 | } | ||
1996 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmesser { | ||
1997 | get { return extmesser_; } | ||
1998 | } | ||
1999 | |||
2000 | public override bool IsInitialized { | ||
2001 | get { | ||
2002 | if (!hasXxfr) return false; | ||
2003 | if (!hasExtmesser) return false; | ||
2004 | if (!ExtensionsAreInitialized) return false; | ||
2005 | return true; | ||
2006 | } | ||
2007 | } | ||
2008 | |||
2009 | public override void WriteTo(pb::CodedOutputStream output) { | ||
2010 | pb::ExtendableMessage<TestMessage, TestMessage.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); | ||
2011 | if (n_.Count > 0) { | ||
2012 | output.WriteRawVarint32(10); | ||
2013 | output.WriteRawVarint32((uint) nMemoizedSerializedSize); | ||
2014 | foreach (float element in n_) { | ||
2015 | output.WriteFloatNoTag(element); | ||
2016 | } | ||
2017 | } | ||
2018 | if (v2F_.Count > 0) { | ||
2019 | output.WriteRawVarint32(18); | ||
2020 | output.WriteRawVarint32((uint) v2FMemoizedSerializedSize); | ||
2021 | foreach (float element in v2F_) { | ||
2022 | output.WriteFloatNoTag(element); | ||
2023 | } | ||
2024 | } | ||
2025 | if (v2D_.Count > 0) { | ||
2026 | output.WriteRawVarint32(26); | ||
2027 | output.WriteRawVarint32((uint) v2DMemoizedSerializedSize); | ||
2028 | foreach (double element in v2D_) { | ||
2029 | output.WriteDoubleNoTag(element); | ||
2030 | } | ||
2031 | } | ||
2032 | if (v3F_.Count > 0) { | ||
2033 | output.WriteRawVarint32(34); | ||
2034 | output.WriteRawVarint32((uint) v3FMemoizedSerializedSize); | ||
2035 | foreach (float element in v3F_) { | ||
2036 | output.WriteFloatNoTag(element); | ||
2037 | } | ||
2038 | } | ||
2039 | if (v3D_.Count > 0) { | ||
2040 | output.WriteRawVarint32(42); | ||
2041 | output.WriteRawVarint32((uint) v3DMemoizedSerializedSize); | ||
2042 | foreach (double element in v3D_) { | ||
2043 | output.WriteDoubleNoTag(element); | ||
2044 | } | ||
2045 | } | ||
2046 | if (v4F_.Count > 0) { | ||
2047 | output.WriteRawVarint32(50); | ||
2048 | output.WriteRawVarint32((uint) v4FMemoizedSerializedSize); | ||
2049 | foreach (float element in v4F_) { | ||
2050 | output.WriteFloatNoTag(element); | ||
2051 | } | ||
2052 | } | ||
2053 | if (v4D_.Count > 0) { | ||
2054 | output.WriteRawVarint32(58); | ||
2055 | output.WriteRawVarint32((uint) v4DMemoizedSerializedSize); | ||
2056 | foreach (double element in v4D_) { | ||
2057 | output.WriteDoubleNoTag(element); | ||
2058 | } | ||
2059 | } | ||
2060 | if (q_.Count > 0) { | ||
2061 | output.WriteRawVarint32(66); | ||
2062 | output.WriteRawVarint32((uint) qMemoizedSerializedSize); | ||
2063 | foreach (float element in q_) { | ||
2064 | output.WriteFloatNoTag(element); | ||
2065 | } | ||
2066 | } | ||
2067 | if (HasU) { | ||
2068 | output.WriteBytes(9, U); | ||
2069 | } | ||
2070 | if (HasA) { | ||
2071 | output.WriteFloat(10, A); | ||
2072 | } | ||
2073 | if (HasT) { | ||
2074 | output.WriteFixed64(11, T); | ||
2075 | } | ||
2076 | if (HasD) { | ||
2077 | output.WriteSFixed64(12, D); | ||
2078 | } | ||
2079 | if (HasF32) { | ||
2080 | output.WriteUInt32(13, F32); | ||
2081 | } | ||
2082 | if (HasF64) { | ||
2083 | output.WriteUInt64(14, F64); | ||
2084 | } | ||
2085 | if (bsf_.Count > 0) { | ||
2086 | output.WriteRawVarint32(122); | ||
2087 | output.WriteRawVarint32((uint) bsfMemoizedSerializedSize); | ||
2088 | foreach (float element in bsf_) { | ||
2089 | output.WriteFloatNoTag(element); | ||
2090 | } | ||
2091 | } | ||
2092 | if (bsd_.Count > 0) { | ||
2093 | output.WriteRawVarint32(130); | ||
2094 | output.WriteRawVarint32((uint) bsdMemoizedSerializedSize); | ||
2095 | foreach (double element in bsd_) { | ||
2096 | output.WriteDoubleNoTag(element); | ||
2097 | } | ||
2098 | } | ||
2099 | if (bbf_.Count > 0) { | ||
2100 | output.WriteRawVarint32(138); | ||
2101 | output.WriteRawVarint32((uint) bbfMemoizedSerializedSize); | ||
2102 | foreach (float element in bbf_) { | ||
2103 | output.WriteFloatNoTag(element); | ||
2104 | } | ||
2105 | } | ||
2106 | if (bbd_.Count > 0) { | ||
2107 | output.WriteRawVarint32(146); | ||
2108 | output.WriteRawVarint32((uint) bbdMemoizedSerializedSize); | ||
2109 | foreach (double element in bbd_) { | ||
2110 | output.WriteDoubleNoTag(element); | ||
2111 | } | ||
2112 | } | ||
2113 | if (HasE32) { | ||
2114 | output.WriteEnum(19, (int) E32); | ||
2115 | } | ||
2116 | if (HasXxd) { | ||
2117 | output.WriteDouble(20, Xxd); | ||
2118 | } | ||
2119 | if (HasXxf) { | ||
2120 | output.WriteFloat(21, Xxf); | ||
2121 | } | ||
2122 | if (HasXxu32) { | ||
2123 | output.WriteUInt32(22, Xxu32); | ||
2124 | } | ||
2125 | if (HasXxs) { | ||
2126 | output.WriteString(23, Xxs); | ||
2127 | } | ||
2128 | if (HasXxb) { | ||
2129 | output.WriteBytes(24, Xxb); | ||
2130 | } | ||
2131 | if (xxss_.Count > 0) { | ||
2132 | foreach (string element in xxss_) { | ||
2133 | output.WriteString(25, element); | ||
2134 | } | ||
2135 | } | ||
2136 | if (xxbb_.Count > 0) { | ||
2137 | foreach (pb::ByteString element in xxbb_) { | ||
2138 | output.WriteBytes(26, element); | ||
2139 | } | ||
2140 | } | ||
2141 | if (xxff_.Count > 0) { | ||
2142 | output.WriteRawVarint32(218); | ||
2143 | output.WriteRawVarint32((uint) xxffMemoizedSerializedSize); | ||
2144 | foreach (float element in xxff_) { | ||
2145 | output.WriteFloatNoTag(element); | ||
2146 | } | ||
2147 | } | ||
2148 | if (HasXxfr) { | ||
2149 | output.WriteFloat(28, Xxfr); | ||
2150 | } | ||
2151 | if (xxnn_.Count > 0) { | ||
2152 | output.WriteRawVarint32(234); | ||
2153 | output.WriteRawVarint32((uint) xxnnMemoizedSerializedSize); | ||
2154 | foreach (float element in xxnn_) { | ||
2155 | output.WriteFloatNoTag(element); | ||
2156 | } | ||
2157 | } | ||
2158 | if (HasSubmes) { | ||
2159 | output.WriteMessage(30, Submes); | ||
2160 | } | ||
2161 | foreach (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage element in SubmessersList) { | ||
2162 | output.WriteMessage(31, element); | ||
2163 | } | ||
2164 | if (HasSha) { | ||
2165 | output.WriteBytes(32, Sha); | ||
2166 | } | ||
2167 | if (shas_.Count > 0) { | ||
2168 | foreach (pb::ByteString element in shas_) { | ||
2169 | output.WriteBytes(33, element); | ||
2170 | } | ||
2171 | } | ||
2172 | if (HasExtmes) { | ||
2173 | output.WriteMessage(34, Extmes); | ||
2174 | } | ||
2175 | foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage element in ExtmessersList) { | ||
2176 | output.WriteMessage(35, element); | ||
2177 | } | ||
2178 | if (HasExtmesser) { | ||
2179 | output.WriteMessage(36, Extmesser); | ||
2180 | } | ||
2181 | extensionWriter.WriteUntil(200, output); | ||
2182 | UnknownFields.WriteTo(output); | ||
2183 | } | ||
2184 | |||
2185 | private int memoizedSerializedSize = -1; | ||
2186 | public override int SerializedSize { | ||
2187 | get { | ||
2188 | int size = memoizedSerializedSize; | ||
2189 | if (size != -1) return size; | ||
2190 | |||
2191 | size = 0; | ||
2192 | if (HasXxd) { | ||
2193 | size += pb::CodedOutputStream.ComputeDoubleSize(20, Xxd); | ||
2194 | } | ||
2195 | if (HasXxf) { | ||
2196 | size += pb::CodedOutputStream.ComputeFloatSize(21, Xxf); | ||
2197 | } | ||
2198 | if (HasXxu32) { | ||
2199 | size += pb::CodedOutputStream.ComputeUInt32Size(22, Xxu32); | ||
2200 | } | ||
2201 | if (HasXxs) { | ||
2202 | size += pb::CodedOutputStream.ComputeStringSize(23, Xxs); | ||
2203 | } | ||
2204 | if (HasXxb) { | ||
2205 | size += pb::CodedOutputStream.ComputeBytesSize(24, Xxb); | ||
2206 | } | ||
2207 | { | ||
2208 | int dataSize = 0; | ||
2209 | foreach (string element in XxssList) { | ||
2210 | dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | ||
2211 | } | ||
2212 | size += dataSize; | ||
2213 | size += 2 * xxss_.Count; | ||
2214 | } | ||
2215 | { | ||
2216 | int dataSize = 0; | ||
2217 | foreach (pb::ByteString element in XxbbList) { | ||
2218 | dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); | ||
2219 | } | ||
2220 | size += dataSize; | ||
2221 | size += 2 * xxbb_.Count; | ||
2222 | } | ||
2223 | { | ||
2224 | int dataSize = 0; | ||
2225 | dataSize = 4 * xxff_.Count; | ||
2226 | size += dataSize; | ||
2227 | if (xxff_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2228 | xxffMemoizedSerializedSize = dataSize; | ||
2229 | } | ||
2230 | { | ||
2231 | int dataSize = 0; | ||
2232 | dataSize = 4 * xxnn_.Count; | ||
2233 | size += dataSize; | ||
2234 | if (xxnn_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2235 | xxnnMemoizedSerializedSize = dataSize; | ||
2236 | } | ||
2237 | if (HasXxfr) { | ||
2238 | size += pb::CodedOutputStream.ComputeFloatSize(28, Xxfr); | ||
2239 | } | ||
2240 | { | ||
2241 | int dataSize = 0; | ||
2242 | dataSize = 4 * n_.Count; | ||
2243 | size += dataSize; | ||
2244 | if (n_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2245 | nMemoizedSerializedSize = dataSize; | ||
2246 | } | ||
2247 | { | ||
2248 | int dataSize = 0; | ||
2249 | dataSize = 4 * v2F_.Count; | ||
2250 | size += dataSize; | ||
2251 | if (v2F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2252 | v2FMemoizedSerializedSize = dataSize; | ||
2253 | } | ||
2254 | { | ||
2255 | int dataSize = 0; | ||
2256 | dataSize = 8 * v2D_.Count; | ||
2257 | size += dataSize; | ||
2258 | if (v2D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2259 | v2DMemoizedSerializedSize = dataSize; | ||
2260 | } | ||
2261 | { | ||
2262 | int dataSize = 0; | ||
2263 | dataSize = 4 * v3F_.Count; | ||
2264 | size += dataSize; | ||
2265 | if (v3F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2266 | v3FMemoizedSerializedSize = dataSize; | ||
2267 | } | ||
2268 | { | ||
2269 | int dataSize = 0; | ||
2270 | dataSize = 8 * v3D_.Count; | ||
2271 | size += dataSize; | ||
2272 | if (v3D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2273 | v3DMemoizedSerializedSize = dataSize; | ||
2274 | } | ||
2275 | { | ||
2276 | int dataSize = 0; | ||
2277 | dataSize = 4 * v4F_.Count; | ||
2278 | size += dataSize; | ||
2279 | if (v4F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2280 | v4FMemoizedSerializedSize = dataSize; | ||
2281 | } | ||
2282 | { | ||
2283 | int dataSize = 0; | ||
2284 | dataSize = 8 * v4D_.Count; | ||
2285 | size += dataSize; | ||
2286 | if (v4D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2287 | v4DMemoizedSerializedSize = dataSize; | ||
2288 | } | ||
2289 | { | ||
2290 | int dataSize = 0; | ||
2291 | dataSize = 4 * q_.Count; | ||
2292 | size += dataSize; | ||
2293 | if (q_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2294 | qMemoizedSerializedSize = dataSize; | ||
2295 | } | ||
2296 | if (HasU) { | ||
2297 | size += pb::CodedOutputStream.ComputeBytesSize(9, U); | ||
2298 | } | ||
2299 | if (HasA) { | ||
2300 | size += pb::CodedOutputStream.ComputeFloatSize(10, A); | ||
2301 | } | ||
2302 | if (HasT) { | ||
2303 | size += pb::CodedOutputStream.ComputeFixed64Size(11, T); | ||
2304 | } | ||
2305 | if (HasD) { | ||
2306 | size += pb::CodedOutputStream.ComputeSFixed64Size(12, D); | ||
2307 | } | ||
2308 | if (HasF32) { | ||
2309 | size += pb::CodedOutputStream.ComputeUInt32Size(13, F32); | ||
2310 | } | ||
2311 | if (HasF64) { | ||
2312 | size += pb::CodedOutputStream.ComputeUInt64Size(14, F64); | ||
2313 | } | ||
2314 | { | ||
2315 | int dataSize = 0; | ||
2316 | dataSize = 4 * bsf_.Count; | ||
2317 | size += dataSize; | ||
2318 | if (bsf_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2319 | bsfMemoizedSerializedSize = dataSize; | ||
2320 | } | ||
2321 | { | ||
2322 | int dataSize = 0; | ||
2323 | dataSize = 8 * bsd_.Count; | ||
2324 | size += dataSize; | ||
2325 | if (bsd_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2326 | bsdMemoizedSerializedSize = dataSize; | ||
2327 | } | ||
2328 | { | ||
2329 | int dataSize = 0; | ||
2330 | dataSize = 4 * bbf_.Count; | ||
2331 | size += dataSize; | ||
2332 | if (bbf_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2333 | bbfMemoizedSerializedSize = dataSize; | ||
2334 | } | ||
2335 | { | ||
2336 | int dataSize = 0; | ||
2337 | dataSize = 8 * bbd_.Count; | ||
2338 | size += dataSize; | ||
2339 | if (bbd_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize); | ||
2340 | bbdMemoizedSerializedSize = dataSize; | ||
2341 | } | ||
2342 | if (HasE32) { | ||
2343 | size += pb::CodedOutputStream.ComputeEnumSize(19, (int) E32); | ||
2344 | } | ||
2345 | if (HasSubmes) { | ||
2346 | size += pb::CodedOutputStream.ComputeMessageSize(30, Submes); | ||
2347 | } | ||
2348 | foreach (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage element in SubmessersList) { | ||
2349 | size += pb::CodedOutputStream.ComputeMessageSize(31, element); | ||
2350 | } | ||
2351 | if (HasSha) { | ||
2352 | size += pb::CodedOutputStream.ComputeBytesSize(32, Sha); | ||
2353 | } | ||
2354 | { | ||
2355 | int dataSize = 0; | ||
2356 | foreach (pb::ByteString element in ShasList) { | ||
2357 | dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element); | ||
2358 | } | ||
2359 | size += dataSize; | ||
2360 | size += 2 * shas_.Count; | ||
2361 | } | ||
2362 | if (HasExtmes) { | ||
2363 | size += pb::CodedOutputStream.ComputeMessageSize(34, Extmes); | ||
2364 | } | ||
2365 | foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage element in ExtmessersList) { | ||
2366 | size += pb::CodedOutputStream.ComputeMessageSize(35, element); | ||
2367 | } | ||
2368 | if (HasExtmesser) { | ||
2369 | size += pb::CodedOutputStream.ComputeMessageSize(36, Extmesser); | ||
2370 | } | ||
2371 | size += ExtensionsSerializedSize; | ||
2372 | size += UnknownFields.SerializedSize; | ||
2373 | memoizedSerializedSize = size; | ||
2374 | return size; | ||
2375 | } | ||
2376 | } | ||
2377 | |||
2378 | public static TestMessage ParseFrom(pb::ByteString data) { | ||
2379 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2380 | } | ||
2381 | public static TestMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
2382 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2383 | } | ||
2384 | public static TestMessage ParseFrom(byte[] data) { | ||
2385 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
2386 | } | ||
2387 | public static TestMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
2388 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
2389 | } | ||
2390 | public static TestMessage ParseFrom(global::System.IO.Stream input) { | ||
2391 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2392 | } | ||
2393 | public static TestMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2394 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2395 | } | ||
2396 | public static TestMessage ParseDelimitedFrom(global::System.IO.Stream input) { | ||
2397 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
2398 | } | ||
2399 | public static TestMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
2400 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
2401 | } | ||
2402 | public static TestMessage ParseFrom(pb::CodedInputStream input) { | ||
2403 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
2404 | } | ||
2405 | public static TestMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2406 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
2407 | } | ||
2408 | public static Builder CreateBuilder() { return new Builder(); } | ||
2409 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
2410 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
2411 | public static Builder CreateBuilder(TestMessage prototype) { | ||
2412 | return (Builder) new Builder().MergeFrom(prototype); | ||
2413 | } | ||
2414 | |||
2415 | public sealed partial class Builder : pb::ExtendableBuilder<TestMessage, Builder> { | ||
2416 | protected override Builder ThisBuilder { | ||
2417 | get { return this; } | ||
2418 | } | ||
2419 | public Builder() {} | ||
2420 | |||
2421 | TestMessage result = new TestMessage(); | ||
2422 | |||
2423 | protected override TestMessage MessageBeingBuilt { | ||
2424 | get { return result; } | ||
2425 | } | ||
2426 | |||
2427 | public override Builder Clear() { | ||
2428 | result = new TestMessage(); | ||
2429 | return this; | ||
2430 | } | ||
2431 | |||
2432 | public override Builder Clone() { | ||
2433 | return new Builder().MergeFrom(result); | ||
2434 | } | ||
2435 | |||
2436 | public override pbd::MessageDescriptor DescriptorForType { | ||
2437 | get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Descriptor; } | ||
2438 | } | ||
2439 | |||
2440 | public override TestMessage DefaultInstanceForType { | ||
2441 | get { return global::Sirikata.PB._PBJ_Internal.TestMessage.DefaultInstance; } | ||
2442 | } | ||
2443 | |||
2444 | public override TestMessage BuildPartial() { | ||
2445 | if (result == null) { | ||
2446 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
2447 | } | ||
2448 | result.xxss_.MakeReadOnly(); | ||
2449 | result.xxbb_.MakeReadOnly(); | ||
2450 | result.xxff_.MakeReadOnly(); | ||
2451 | result.xxnn_.MakeReadOnly(); | ||
2452 | result.n_.MakeReadOnly(); | ||
2453 | result.v2F_.MakeReadOnly(); | ||
2454 | result.v2D_.MakeReadOnly(); | ||
2455 | result.v3F_.MakeReadOnly(); | ||
2456 | result.v3D_.MakeReadOnly(); | ||
2457 | result.v4F_.MakeReadOnly(); | ||
2458 | result.v4D_.MakeReadOnly(); | ||
2459 | result.q_.MakeReadOnly(); | ||
2460 | result.bsf_.MakeReadOnly(); | ||
2461 | result.bsd_.MakeReadOnly(); | ||
2462 | result.bbf_.MakeReadOnly(); | ||
2463 | result.bbd_.MakeReadOnly(); | ||
2464 | result.submessers_.MakeReadOnly(); | ||
2465 | result.shas_.MakeReadOnly(); | ||
2466 | result.extmessers_.MakeReadOnly(); | ||
2467 | TestMessage returnMe = result; | ||
2468 | result = null; | ||
2469 | return returnMe; | ||
2470 | } | ||
2471 | |||
2472 | public override Builder MergeFrom(pb::IMessage other) { | ||
2473 | if (other is TestMessage) { | ||
2474 | return MergeFrom((TestMessage) other); | ||
2475 | } else { | ||
2476 | base.MergeFrom(other); | ||
2477 | return this; | ||
2478 | } | ||
2479 | } | ||
2480 | |||
2481 | public override Builder MergeFrom(TestMessage other) { | ||
2482 | if (other == global::Sirikata.PB._PBJ_Internal.TestMessage.DefaultInstance) return this; | ||
2483 | if (other.HasXxd) { | ||
2484 | Xxd = other.Xxd; | ||
2485 | } | ||
2486 | if (other.HasXxf) { | ||
2487 | Xxf = other.Xxf; | ||
2488 | } | ||
2489 | if (other.HasXxu32) { | ||
2490 | Xxu32 = other.Xxu32; | ||
2491 | } | ||
2492 | if (other.HasXxs) { | ||
2493 | Xxs = other.Xxs; | ||
2494 | } | ||
2495 | if (other.HasXxb) { | ||
2496 | Xxb = other.Xxb; | ||
2497 | } | ||
2498 | if (other.xxss_.Count != 0) { | ||
2499 | base.AddRange(other.xxss_, result.xxss_); | ||
2500 | } | ||
2501 | if (other.xxbb_.Count != 0) { | ||
2502 | base.AddRange(other.xxbb_, result.xxbb_); | ||
2503 | } | ||
2504 | if (other.xxff_.Count != 0) { | ||
2505 | base.AddRange(other.xxff_, result.xxff_); | ||
2506 | } | ||
2507 | if (other.xxnn_.Count != 0) { | ||
2508 | base.AddRange(other.xxnn_, result.xxnn_); | ||
2509 | } | ||
2510 | if (other.HasXxfr) { | ||
2511 | Xxfr = other.Xxfr; | ||
2512 | } | ||
2513 | if (other.n_.Count != 0) { | ||
2514 | base.AddRange(other.n_, result.n_); | ||
2515 | } | ||
2516 | if (other.v2F_.Count != 0) { | ||
2517 | base.AddRange(other.v2F_, result.v2F_); | ||
2518 | } | ||
2519 | if (other.v2D_.Count != 0) { | ||
2520 | base.AddRange(other.v2D_, result.v2D_); | ||
2521 | } | ||
2522 | if (other.v3F_.Count != 0) { | ||
2523 | base.AddRange(other.v3F_, result.v3F_); | ||
2524 | } | ||
2525 | if (other.v3D_.Count != 0) { | ||
2526 | base.AddRange(other.v3D_, result.v3D_); | ||
2527 | } | ||
2528 | if (other.v4F_.Count != 0) { | ||
2529 | base.AddRange(other.v4F_, result.v4F_); | ||
2530 | } | ||
2531 | if (other.v4D_.Count != 0) { | ||
2532 | base.AddRange(other.v4D_, result.v4D_); | ||
2533 | } | ||
2534 | if (other.q_.Count != 0) { | ||
2535 | base.AddRange(other.q_, result.q_); | ||
2536 | } | ||
2537 | if (other.HasU) { | ||
2538 | U = other.U; | ||
2539 | } | ||
2540 | if (other.HasA) { | ||
2541 | A = other.A; | ||
2542 | } | ||
2543 | if (other.HasT) { | ||
2544 | T = other.T; | ||
2545 | } | ||
2546 | if (other.HasD) { | ||
2547 | D = other.D; | ||
2548 | } | ||
2549 | if (other.HasF32) { | ||
2550 | F32 = other.F32; | ||
2551 | } | ||
2552 | if (other.HasF64) { | ||
2553 | F64 = other.F64; | ||
2554 | } | ||
2555 | if (other.bsf_.Count != 0) { | ||
2556 | base.AddRange(other.bsf_, result.bsf_); | ||
2557 | } | ||
2558 | if (other.bsd_.Count != 0) { | ||
2559 | base.AddRange(other.bsd_, result.bsd_); | ||
2560 | } | ||
2561 | if (other.bbf_.Count != 0) { | ||
2562 | base.AddRange(other.bbf_, result.bbf_); | ||
2563 | } | ||
2564 | if (other.bbd_.Count != 0) { | ||
2565 | base.AddRange(other.bbd_, result.bbd_); | ||
2566 | } | ||
2567 | if (other.HasE32) { | ||
2568 | E32 = other.E32; | ||
2569 | } | ||
2570 | if (other.HasSubmes) { | ||
2571 | MergeSubmes(other.Submes); | ||
2572 | } | ||
2573 | if (other.submessers_.Count != 0) { | ||
2574 | base.AddRange(other.submessers_, result.submessers_); | ||
2575 | } | ||
2576 | if (other.HasSha) { | ||
2577 | Sha = other.Sha; | ||
2578 | } | ||
2579 | if (other.shas_.Count != 0) { | ||
2580 | base.AddRange(other.shas_, result.shas_); | ||
2581 | } | ||
2582 | if (other.HasExtmes) { | ||
2583 | MergeExtmes(other.Extmes); | ||
2584 | } | ||
2585 | if (other.extmessers_.Count != 0) { | ||
2586 | base.AddRange(other.extmessers_, result.extmessers_); | ||
2587 | } | ||
2588 | if (other.HasExtmesser) { | ||
2589 | MergeExtmesser(other.Extmesser); | ||
2590 | } | ||
2591 | this.MergeExtensionFields(other); | ||
2592 | this.MergeUnknownFields(other.UnknownFields); | ||
2593 | return this; | ||
2594 | } | ||
2595 | |||
2596 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
2597 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
2598 | } | ||
2599 | |||
2600 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
2601 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
2602 | while (true) { | ||
2603 | uint tag = input.ReadTag(); | ||
2604 | switch (tag) { | ||
2605 | case 0: { | ||
2606 | if (unknownFields != null) { | ||
2607 | this.UnknownFields = unknownFields.Build(); | ||
2608 | } | ||
2609 | return this; | ||
2610 | } | ||
2611 | default: { | ||
2612 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
2613 | if (unknownFields != null) { | ||
2614 | this.UnknownFields = unknownFields.Build(); | ||
2615 | } | ||
2616 | return this; | ||
2617 | } | ||
2618 | if (unknownFields == null) { | ||
2619 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2620 | } | ||
2621 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
2622 | break; | ||
2623 | } | ||
2624 | case 10: { | ||
2625 | int length = input.ReadInt32(); | ||
2626 | int limit = input.PushLimit(length); | ||
2627 | while (!input.ReachedLimit) { | ||
2628 | AddN(input.ReadFloat()); | ||
2629 | } | ||
2630 | input.PopLimit(limit); | ||
2631 | break; | ||
2632 | } | ||
2633 | case 18: { | ||
2634 | int length = input.ReadInt32(); | ||
2635 | int limit = input.PushLimit(length); | ||
2636 | while (!input.ReachedLimit) { | ||
2637 | AddV2F(input.ReadFloat()); | ||
2638 | } | ||
2639 | input.PopLimit(limit); | ||
2640 | break; | ||
2641 | } | ||
2642 | case 26: { | ||
2643 | int length = input.ReadInt32(); | ||
2644 | int limit = input.PushLimit(length); | ||
2645 | while (!input.ReachedLimit) { | ||
2646 | AddV2D(input.ReadDouble()); | ||
2647 | } | ||
2648 | input.PopLimit(limit); | ||
2649 | break; | ||
2650 | } | ||
2651 | case 34: { | ||
2652 | int length = input.ReadInt32(); | ||
2653 | int limit = input.PushLimit(length); | ||
2654 | while (!input.ReachedLimit) { | ||
2655 | AddV3F(input.ReadFloat()); | ||
2656 | } | ||
2657 | input.PopLimit(limit); | ||
2658 | break; | ||
2659 | } | ||
2660 | case 42: { | ||
2661 | int length = input.ReadInt32(); | ||
2662 | int limit = input.PushLimit(length); | ||
2663 | while (!input.ReachedLimit) { | ||
2664 | AddV3D(input.ReadDouble()); | ||
2665 | } | ||
2666 | input.PopLimit(limit); | ||
2667 | break; | ||
2668 | } | ||
2669 | case 50: { | ||
2670 | int length = input.ReadInt32(); | ||
2671 | int limit = input.PushLimit(length); | ||
2672 | while (!input.ReachedLimit) { | ||
2673 | AddV4F(input.ReadFloat()); | ||
2674 | } | ||
2675 | input.PopLimit(limit); | ||
2676 | break; | ||
2677 | } | ||
2678 | case 58: { | ||
2679 | int length = input.ReadInt32(); | ||
2680 | int limit = input.PushLimit(length); | ||
2681 | while (!input.ReachedLimit) { | ||
2682 | AddV4D(input.ReadDouble()); | ||
2683 | } | ||
2684 | input.PopLimit(limit); | ||
2685 | break; | ||
2686 | } | ||
2687 | case 66: { | ||
2688 | int length = input.ReadInt32(); | ||
2689 | int limit = input.PushLimit(length); | ||
2690 | while (!input.ReachedLimit) { | ||
2691 | AddQ(input.ReadFloat()); | ||
2692 | } | ||
2693 | input.PopLimit(limit); | ||
2694 | break; | ||
2695 | } | ||
2696 | case 74: { | ||
2697 | U = input.ReadBytes(); | ||
2698 | break; | ||
2699 | } | ||
2700 | case 85: { | ||
2701 | A = input.ReadFloat(); | ||
2702 | break; | ||
2703 | } | ||
2704 | case 89: { | ||
2705 | T = input.ReadFixed64(); | ||
2706 | break; | ||
2707 | } | ||
2708 | case 97: { | ||
2709 | D = input.ReadSFixed64(); | ||
2710 | break; | ||
2711 | } | ||
2712 | case 104: { | ||
2713 | F32 = input.ReadUInt32(); | ||
2714 | break; | ||
2715 | } | ||
2716 | case 112: { | ||
2717 | F64 = input.ReadUInt64(); | ||
2718 | break; | ||
2719 | } | ||
2720 | case 122: { | ||
2721 | int length = input.ReadInt32(); | ||
2722 | int limit = input.PushLimit(length); | ||
2723 | while (!input.ReachedLimit) { | ||
2724 | AddBsf(input.ReadFloat()); | ||
2725 | } | ||
2726 | input.PopLimit(limit); | ||
2727 | break; | ||
2728 | } | ||
2729 | case 130: { | ||
2730 | int length = input.ReadInt32(); | ||
2731 | int limit = input.PushLimit(length); | ||
2732 | while (!input.ReachedLimit) { | ||
2733 | AddBsd(input.ReadDouble()); | ||
2734 | } | ||
2735 | input.PopLimit(limit); | ||
2736 | break; | ||
2737 | } | ||
2738 | case 138: { | ||
2739 | int length = input.ReadInt32(); | ||
2740 | int limit = input.PushLimit(length); | ||
2741 | while (!input.ReachedLimit) { | ||
2742 | AddBbf(input.ReadFloat()); | ||
2743 | } | ||
2744 | input.PopLimit(limit); | ||
2745 | break; | ||
2746 | } | ||
2747 | case 146: { | ||
2748 | int length = input.ReadInt32(); | ||
2749 | int limit = input.PushLimit(length); | ||
2750 | while (!input.ReachedLimit) { | ||
2751 | AddBbd(input.ReadDouble()); | ||
2752 | } | ||
2753 | input.PopLimit(limit); | ||
2754 | break; | ||
2755 | } | ||
2756 | case 152: { | ||
2757 | int rawValue = input.ReadEnum(); | ||
2758 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32), rawValue)) { | ||
2759 | if (unknownFields == null) { | ||
2760 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
2761 | } | ||
2762 | unknownFields.MergeVarintField(19, (ulong) rawValue); | ||
2763 | } else { | ||
2764 | E32 = (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32) rawValue; | ||
2765 | } | ||
2766 | break; | ||
2767 | } | ||
2768 | case 161: { | ||
2769 | Xxd = input.ReadDouble(); | ||
2770 | break; | ||
2771 | } | ||
2772 | case 173: { | ||
2773 | Xxf = input.ReadFloat(); | ||
2774 | break; | ||
2775 | } | ||
2776 | case 176: { | ||
2777 | Xxu32 = input.ReadUInt32(); | ||
2778 | break; | ||
2779 | } | ||
2780 | case 186: { | ||
2781 | Xxs = input.ReadString(); | ||
2782 | break; | ||
2783 | } | ||
2784 | case 194: { | ||
2785 | Xxb = input.ReadBytes(); | ||
2786 | break; | ||
2787 | } | ||
2788 | case 202: { | ||
2789 | AddXxss(input.ReadString()); | ||
2790 | break; | ||
2791 | } | ||
2792 | case 210: { | ||
2793 | AddXxbb(input.ReadBytes()); | ||
2794 | break; | ||
2795 | } | ||
2796 | case 218: { | ||
2797 | int length = input.ReadInt32(); | ||
2798 | int limit = input.PushLimit(length); | ||
2799 | while (!input.ReachedLimit) { | ||
2800 | AddXxff(input.ReadFloat()); | ||
2801 | } | ||
2802 | input.PopLimit(limit); | ||
2803 | break; | ||
2804 | } | ||
2805 | case 229: { | ||
2806 | Xxfr = input.ReadFloat(); | ||
2807 | break; | ||
2808 | } | ||
2809 | case 234: { | ||
2810 | int length = input.ReadInt32(); | ||
2811 | int limit = input.PushLimit(length); | ||
2812 | while (!input.ReachedLimit) { | ||
2813 | AddXxnn(input.ReadFloat()); | ||
2814 | } | ||
2815 | input.PopLimit(limit); | ||
2816 | break; | ||
2817 | } | ||
2818 | case 242: { | ||
2819 | global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder(); | ||
2820 | if (HasSubmes) { | ||
2821 | subBuilder.MergeFrom(Submes); | ||
2822 | } | ||
2823 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2824 | Submes = subBuilder.BuildPartial(); | ||
2825 | break; | ||
2826 | } | ||
2827 | case 250: { | ||
2828 | global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder(); | ||
2829 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2830 | AddSubmessers(subBuilder.BuildPartial()); | ||
2831 | break; | ||
2832 | } | ||
2833 | case 258: { | ||
2834 | Sha = input.ReadBytes(); | ||
2835 | break; | ||
2836 | } | ||
2837 | case 266: { | ||
2838 | AddShas(input.ReadBytes()); | ||
2839 | break; | ||
2840 | } | ||
2841 | case 274: { | ||
2842 | global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(); | ||
2843 | if (HasExtmes) { | ||
2844 | subBuilder.MergeFrom(Extmes); | ||
2845 | } | ||
2846 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2847 | Extmes = subBuilder.BuildPartial(); | ||
2848 | break; | ||
2849 | } | ||
2850 | case 282: { | ||
2851 | global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(); | ||
2852 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2853 | AddExtmessers(subBuilder.BuildPartial()); | ||
2854 | break; | ||
2855 | } | ||
2856 | case 290: { | ||
2857 | global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(); | ||
2858 | if (HasExtmesser) { | ||
2859 | subBuilder.MergeFrom(Extmesser); | ||
2860 | } | ||
2861 | input.ReadMessage(subBuilder, extensionRegistry); | ||
2862 | Extmesser = subBuilder.BuildPartial(); | ||
2863 | break; | ||
2864 | } | ||
2865 | } | ||
2866 | } | ||
2867 | } | ||
2868 | |||
2869 | |||
2870 | public bool HasXxd { | ||
2871 | get { return result.HasXxd; } | ||
2872 | } | ||
2873 | public double Xxd { | ||
2874 | get { return result.Xxd; } | ||
2875 | set { SetXxd(value); } | ||
2876 | } | ||
2877 | public Builder SetXxd(double value) { | ||
2878 | result.hasXxd = true; | ||
2879 | result.xxd_ = value; | ||
2880 | return this; | ||
2881 | } | ||
2882 | public Builder ClearXxd() { | ||
2883 | result.hasXxd = false; | ||
2884 | result.xxd_ = 10.3D; | ||
2885 | return this; | ||
2886 | } | ||
2887 | |||
2888 | public bool HasXxf { | ||
2889 | get { return result.HasXxf; } | ||
2890 | } | ||
2891 | public float Xxf { | ||
2892 | get { return result.Xxf; } | ||
2893 | set { SetXxf(value); } | ||
2894 | } | ||
2895 | public Builder SetXxf(float value) { | ||
2896 | result.hasXxf = true; | ||
2897 | result.xxf_ = value; | ||
2898 | return this; | ||
2899 | } | ||
2900 | public Builder ClearXxf() { | ||
2901 | result.hasXxf = false; | ||
2902 | result.xxf_ = 0F; | ||
2903 | return this; | ||
2904 | } | ||
2905 | |||
2906 | public bool HasXxu32 { | ||
2907 | get { return result.HasXxu32; } | ||
2908 | } | ||
2909 | [global::System.CLSCompliant(false)] | ||
2910 | public uint Xxu32 { | ||
2911 | get { return result.Xxu32; } | ||
2912 | set { SetXxu32(value); } | ||
2913 | } | ||
2914 | [global::System.CLSCompliant(false)] | ||
2915 | public Builder SetXxu32(uint value) { | ||
2916 | result.hasXxu32 = true; | ||
2917 | result.xxu32_ = value; | ||
2918 | return this; | ||
2919 | } | ||
2920 | public Builder ClearXxu32() { | ||
2921 | result.hasXxu32 = false; | ||
2922 | result.xxu32_ = 0; | ||
2923 | return this; | ||
2924 | } | ||
2925 | |||
2926 | public bool HasXxs { | ||
2927 | get { return result.HasXxs; } | ||
2928 | } | ||
2929 | public string Xxs { | ||
2930 | get { return result.Xxs; } | ||
2931 | set { SetXxs(value); } | ||
2932 | } | ||
2933 | public Builder SetXxs(string value) { | ||
2934 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2935 | result.hasXxs = true; | ||
2936 | result.xxs_ = value; | ||
2937 | return this; | ||
2938 | } | ||
2939 | public Builder ClearXxs() { | ||
2940 | result.hasXxs = false; | ||
2941 | result.xxs_ = ""; | ||
2942 | return this; | ||
2943 | } | ||
2944 | |||
2945 | public bool HasXxb { | ||
2946 | get { return result.HasXxb; } | ||
2947 | } | ||
2948 | public pb::ByteString Xxb { | ||
2949 | get { return result.Xxb; } | ||
2950 | set { SetXxb(value); } | ||
2951 | } | ||
2952 | public Builder SetXxb(pb::ByteString value) { | ||
2953 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2954 | result.hasXxb = true; | ||
2955 | result.xxb_ = value; | ||
2956 | return this; | ||
2957 | } | ||
2958 | public Builder ClearXxb() { | ||
2959 | result.hasXxb = false; | ||
2960 | result.xxb_ = pb::ByteString.Empty; | ||
2961 | return this; | ||
2962 | } | ||
2963 | |||
2964 | public pbc::IPopsicleList<string> XxssList { | ||
2965 | get { return result.xxss_; } | ||
2966 | } | ||
2967 | public int XxssCount { | ||
2968 | get { return result.XxssCount; } | ||
2969 | } | ||
2970 | public string GetXxss(int index) { | ||
2971 | return result.GetXxss(index); | ||
2972 | } | ||
2973 | public Builder SetXxss(int index, string value) { | ||
2974 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2975 | result.xxss_[index] = value; | ||
2976 | return this; | ||
2977 | } | ||
2978 | public Builder AddXxss(string value) { | ||
2979 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
2980 | result.xxss_.Add(value); | ||
2981 | return this; | ||
2982 | } | ||
2983 | public Builder AddRangeXxss(scg::IEnumerable<string> values) { | ||
2984 | base.AddRange(values, result.xxss_); | ||
2985 | return this; | ||
2986 | } | ||
2987 | public Builder ClearXxss() { | ||
2988 | result.xxss_.Clear(); | ||
2989 | return this; | ||
2990 | } | ||
2991 | |||
2992 | public pbc::IPopsicleList<pb::ByteString> XxbbList { | ||
2993 | get { return result.xxbb_; } | ||
2994 | } | ||
2995 | public int XxbbCount { | ||
2996 | get { return result.XxbbCount; } | ||
2997 | } | ||
2998 | public pb::ByteString GetXxbb(int index) { | ||
2999 | return result.GetXxbb(index); | ||
3000 | } | ||
3001 | public Builder SetXxbb(int index, pb::ByteString value) { | ||
3002 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3003 | result.xxbb_[index] = value; | ||
3004 | return this; | ||
3005 | } | ||
3006 | public Builder AddXxbb(pb::ByteString value) { | ||
3007 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3008 | result.xxbb_.Add(value); | ||
3009 | return this; | ||
3010 | } | ||
3011 | public Builder AddRangeXxbb(scg::IEnumerable<pb::ByteString> values) { | ||
3012 | base.AddRange(values, result.xxbb_); | ||
3013 | return this; | ||
3014 | } | ||
3015 | public Builder ClearXxbb() { | ||
3016 | result.xxbb_.Clear(); | ||
3017 | return this; | ||
3018 | } | ||
3019 | |||
3020 | public pbc::IPopsicleList<float> XxffList { | ||
3021 | get { return result.xxff_; } | ||
3022 | } | ||
3023 | public int XxffCount { | ||
3024 | get { return result.XxffCount; } | ||
3025 | } | ||
3026 | public float GetXxff(int index) { | ||
3027 | return result.GetXxff(index); | ||
3028 | } | ||
3029 | public Builder SetXxff(int index, float value) { | ||
3030 | result.xxff_[index] = value; | ||
3031 | return this; | ||
3032 | } | ||
3033 | public Builder AddXxff(float value) { | ||
3034 | result.xxff_.Add(value); | ||
3035 | return this; | ||
3036 | } | ||
3037 | public Builder AddRangeXxff(scg::IEnumerable<float> values) { | ||
3038 | base.AddRange(values, result.xxff_); | ||
3039 | return this; | ||
3040 | } | ||
3041 | public Builder ClearXxff() { | ||
3042 | result.xxff_.Clear(); | ||
3043 | return this; | ||
3044 | } | ||
3045 | |||
3046 | public pbc::IPopsicleList<float> XxnnList { | ||
3047 | get { return result.xxnn_; } | ||
3048 | } | ||
3049 | public int XxnnCount { | ||
3050 | get { return result.XxnnCount; } | ||
3051 | } | ||
3052 | public float GetXxnn(int index) { | ||
3053 | return result.GetXxnn(index); | ||
3054 | } | ||
3055 | public Builder SetXxnn(int index, float value) { | ||
3056 | result.xxnn_[index] = value; | ||
3057 | return this; | ||
3058 | } | ||
3059 | public Builder AddXxnn(float value) { | ||
3060 | result.xxnn_.Add(value); | ||
3061 | return this; | ||
3062 | } | ||
3063 | public Builder AddRangeXxnn(scg::IEnumerable<float> values) { | ||
3064 | base.AddRange(values, result.xxnn_); | ||
3065 | return this; | ||
3066 | } | ||
3067 | public Builder ClearXxnn() { | ||
3068 | result.xxnn_.Clear(); | ||
3069 | return this; | ||
3070 | } | ||
3071 | |||
3072 | public bool HasXxfr { | ||
3073 | get { return result.HasXxfr; } | ||
3074 | } | ||
3075 | public float Xxfr { | ||
3076 | get { return result.Xxfr; } | ||
3077 | set { SetXxfr(value); } | ||
3078 | } | ||
3079 | public Builder SetXxfr(float value) { | ||
3080 | result.hasXxfr = true; | ||
3081 | result.xxfr_ = value; | ||
3082 | return this; | ||
3083 | } | ||
3084 | public Builder ClearXxfr() { | ||
3085 | result.hasXxfr = false; | ||
3086 | result.xxfr_ = 0F; | ||
3087 | return this; | ||
3088 | } | ||
3089 | |||
3090 | public pbc::IPopsicleList<float> NList { | ||
3091 | get { return result.n_; } | ||
3092 | } | ||
3093 | public int NCount { | ||
3094 | get { return result.NCount; } | ||
3095 | } | ||
3096 | public float GetN(int index) { | ||
3097 | return result.GetN(index); | ||
3098 | } | ||
3099 | public Builder SetN(int index, float value) { | ||
3100 | result.n_[index] = value; | ||
3101 | return this; | ||
3102 | } | ||
3103 | public Builder AddN(float value) { | ||
3104 | result.n_.Add(value); | ||
3105 | return this; | ||
3106 | } | ||
3107 | public Builder AddRangeN(scg::IEnumerable<float> values) { | ||
3108 | base.AddRange(values, result.n_); | ||
3109 | return this; | ||
3110 | } | ||
3111 | public Builder ClearN() { | ||
3112 | result.n_.Clear(); | ||
3113 | return this; | ||
3114 | } | ||
3115 | |||
3116 | public pbc::IPopsicleList<float> V2FList { | ||
3117 | get { return result.v2F_; } | ||
3118 | } | ||
3119 | public int V2FCount { | ||
3120 | get { return result.V2FCount; } | ||
3121 | } | ||
3122 | public float GetV2F(int index) { | ||
3123 | return result.GetV2F(index); | ||
3124 | } | ||
3125 | public Builder SetV2F(int index, float value) { | ||
3126 | result.v2F_[index] = value; | ||
3127 | return this; | ||
3128 | } | ||
3129 | public Builder AddV2F(float value) { | ||
3130 | result.v2F_.Add(value); | ||
3131 | return this; | ||
3132 | } | ||
3133 | public Builder AddRangeV2F(scg::IEnumerable<float> values) { | ||
3134 | base.AddRange(values, result.v2F_); | ||
3135 | return this; | ||
3136 | } | ||
3137 | public Builder ClearV2F() { | ||
3138 | result.v2F_.Clear(); | ||
3139 | return this; | ||
3140 | } | ||
3141 | |||
3142 | public pbc::IPopsicleList<double> V2DList { | ||
3143 | get { return result.v2D_; } | ||
3144 | } | ||
3145 | public int V2DCount { | ||
3146 | get { return result.V2DCount; } | ||
3147 | } | ||
3148 | public double GetV2D(int index) { | ||
3149 | return result.GetV2D(index); | ||
3150 | } | ||
3151 | public Builder SetV2D(int index, double value) { | ||
3152 | result.v2D_[index] = value; | ||
3153 | return this; | ||
3154 | } | ||
3155 | public Builder AddV2D(double value) { | ||
3156 | result.v2D_.Add(value); | ||
3157 | return this; | ||
3158 | } | ||
3159 | public Builder AddRangeV2D(scg::IEnumerable<double> values) { | ||
3160 | base.AddRange(values, result.v2D_); | ||
3161 | return this; | ||
3162 | } | ||
3163 | public Builder ClearV2D() { | ||
3164 | result.v2D_.Clear(); | ||
3165 | return this; | ||
3166 | } | ||
3167 | |||
3168 | public pbc::IPopsicleList<float> V3FList { | ||
3169 | get { return result.v3F_; } | ||
3170 | } | ||
3171 | public int V3FCount { | ||
3172 | get { return result.V3FCount; } | ||
3173 | } | ||
3174 | public float GetV3F(int index) { | ||
3175 | return result.GetV3F(index); | ||
3176 | } | ||
3177 | public Builder SetV3F(int index, float value) { | ||
3178 | result.v3F_[index] = value; | ||
3179 | return this; | ||
3180 | } | ||
3181 | public Builder AddV3F(float value) { | ||
3182 | result.v3F_.Add(value); | ||
3183 | return this; | ||
3184 | } | ||
3185 | public Builder AddRangeV3F(scg::IEnumerable<float> values) { | ||
3186 | base.AddRange(values, result.v3F_); | ||
3187 | return this; | ||
3188 | } | ||
3189 | public Builder ClearV3F() { | ||
3190 | result.v3F_.Clear(); | ||
3191 | return this; | ||
3192 | } | ||
3193 | |||
3194 | public pbc::IPopsicleList<double> V3DList { | ||
3195 | get { return result.v3D_; } | ||
3196 | } | ||
3197 | public int V3DCount { | ||
3198 | get { return result.V3DCount; } | ||
3199 | } | ||
3200 | public double GetV3D(int index) { | ||
3201 | return result.GetV3D(index); | ||
3202 | } | ||
3203 | public Builder SetV3D(int index, double value) { | ||
3204 | result.v3D_[index] = value; | ||
3205 | return this; | ||
3206 | } | ||
3207 | public Builder AddV3D(double value) { | ||
3208 | result.v3D_.Add(value); | ||
3209 | return this; | ||
3210 | } | ||
3211 | public Builder AddRangeV3D(scg::IEnumerable<double> values) { | ||
3212 | base.AddRange(values, result.v3D_); | ||
3213 | return this; | ||
3214 | } | ||
3215 | public Builder ClearV3D() { | ||
3216 | result.v3D_.Clear(); | ||
3217 | return this; | ||
3218 | } | ||
3219 | |||
3220 | public pbc::IPopsicleList<float> V4FList { | ||
3221 | get { return result.v4F_; } | ||
3222 | } | ||
3223 | public int V4FCount { | ||
3224 | get { return result.V4FCount; } | ||
3225 | } | ||
3226 | public float GetV4F(int index) { | ||
3227 | return result.GetV4F(index); | ||
3228 | } | ||
3229 | public Builder SetV4F(int index, float value) { | ||
3230 | result.v4F_[index] = value; | ||
3231 | return this; | ||
3232 | } | ||
3233 | public Builder AddV4F(float value) { | ||
3234 | result.v4F_.Add(value); | ||
3235 | return this; | ||
3236 | } | ||
3237 | public Builder AddRangeV4F(scg::IEnumerable<float> values) { | ||
3238 | base.AddRange(values, result.v4F_); | ||
3239 | return this; | ||
3240 | } | ||
3241 | public Builder ClearV4F() { | ||
3242 | result.v4F_.Clear(); | ||
3243 | return this; | ||
3244 | } | ||
3245 | |||
3246 | public pbc::IPopsicleList<double> V4DList { | ||
3247 | get { return result.v4D_; } | ||
3248 | } | ||
3249 | public int V4DCount { | ||
3250 | get { return result.V4DCount; } | ||
3251 | } | ||
3252 | public double GetV4D(int index) { | ||
3253 | return result.GetV4D(index); | ||
3254 | } | ||
3255 | public Builder SetV4D(int index, double value) { | ||
3256 | result.v4D_[index] = value; | ||
3257 | return this; | ||
3258 | } | ||
3259 | public Builder AddV4D(double value) { | ||
3260 | result.v4D_.Add(value); | ||
3261 | return this; | ||
3262 | } | ||
3263 | public Builder AddRangeV4D(scg::IEnumerable<double> values) { | ||
3264 | base.AddRange(values, result.v4D_); | ||
3265 | return this; | ||
3266 | } | ||
3267 | public Builder ClearV4D() { | ||
3268 | result.v4D_.Clear(); | ||
3269 | return this; | ||
3270 | } | ||
3271 | |||
3272 | public pbc::IPopsicleList<float> QList { | ||
3273 | get { return result.q_; } | ||
3274 | } | ||
3275 | public int QCount { | ||
3276 | get { return result.QCount; } | ||
3277 | } | ||
3278 | public float GetQ(int index) { | ||
3279 | return result.GetQ(index); | ||
3280 | } | ||
3281 | public Builder SetQ(int index, float value) { | ||
3282 | result.q_[index] = value; | ||
3283 | return this; | ||
3284 | } | ||
3285 | public Builder AddQ(float value) { | ||
3286 | result.q_.Add(value); | ||
3287 | return this; | ||
3288 | } | ||
3289 | public Builder AddRangeQ(scg::IEnumerable<float> values) { | ||
3290 | base.AddRange(values, result.q_); | ||
3291 | return this; | ||
3292 | } | ||
3293 | public Builder ClearQ() { | ||
3294 | result.q_.Clear(); | ||
3295 | return this; | ||
3296 | } | ||
3297 | |||
3298 | public bool HasU { | ||
3299 | get { return result.HasU; } | ||
3300 | } | ||
3301 | public pb::ByteString U { | ||
3302 | get { return result.U; } | ||
3303 | set { SetU(value); } | ||
3304 | } | ||
3305 | public Builder SetU(pb::ByteString value) { | ||
3306 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3307 | result.hasU = true; | ||
3308 | result.u_ = value; | ||
3309 | return this; | ||
3310 | } | ||
3311 | public Builder ClearU() { | ||
3312 | result.hasU = false; | ||
3313 | result.u_ = pb::ByteString.Empty; | ||
3314 | return this; | ||
3315 | } | ||
3316 | |||
3317 | public bool HasA { | ||
3318 | get { return result.HasA; } | ||
3319 | } | ||
3320 | public float A { | ||
3321 | get { return result.A; } | ||
3322 | set { SetA(value); } | ||
3323 | } | ||
3324 | public Builder SetA(float value) { | ||
3325 | result.hasA = true; | ||
3326 | result.a_ = value; | ||
3327 | return this; | ||
3328 | } | ||
3329 | public Builder ClearA() { | ||
3330 | result.hasA = false; | ||
3331 | result.a_ = 0F; | ||
3332 | return this; | ||
3333 | } | ||
3334 | |||
3335 | public bool HasT { | ||
3336 | get { return result.HasT; } | ||
3337 | } | ||
3338 | [global::System.CLSCompliant(false)] | ||
3339 | public ulong T { | ||
3340 | get { return result.T; } | ||
3341 | set { SetT(value); } | ||
3342 | } | ||
3343 | [global::System.CLSCompliant(false)] | ||
3344 | public Builder SetT(ulong value) { | ||
3345 | result.hasT = true; | ||
3346 | result.t_ = value; | ||
3347 | return this; | ||
3348 | } | ||
3349 | public Builder ClearT() { | ||
3350 | result.hasT = false; | ||
3351 | result.t_ = 0; | ||
3352 | return this; | ||
3353 | } | ||
3354 | |||
3355 | public bool HasD { | ||
3356 | get { return result.HasD; } | ||
3357 | } | ||
3358 | public long D { | ||
3359 | get { return result.D; } | ||
3360 | set { SetD(value); } | ||
3361 | } | ||
3362 | public Builder SetD(long value) { | ||
3363 | result.hasD = true; | ||
3364 | result.d_ = value; | ||
3365 | return this; | ||
3366 | } | ||
3367 | public Builder ClearD() { | ||
3368 | result.hasD = false; | ||
3369 | result.d_ = 0; | ||
3370 | return this; | ||
3371 | } | ||
3372 | |||
3373 | public bool HasF32 { | ||
3374 | get { return result.HasF32; } | ||
3375 | } | ||
3376 | [global::System.CLSCompliant(false)] | ||
3377 | public uint F32 { | ||
3378 | get { return result.F32; } | ||
3379 | set { SetF32(value); } | ||
3380 | } | ||
3381 | [global::System.CLSCompliant(false)] | ||
3382 | public Builder SetF32(uint value) { | ||
3383 | result.hasF32 = true; | ||
3384 | result.f32_ = value; | ||
3385 | return this; | ||
3386 | } | ||
3387 | public Builder ClearF32() { | ||
3388 | result.hasF32 = false; | ||
3389 | result.f32_ = 0; | ||
3390 | return this; | ||
3391 | } | ||
3392 | |||
3393 | public bool HasF64 { | ||
3394 | get { return result.HasF64; } | ||
3395 | } | ||
3396 | [global::System.CLSCompliant(false)] | ||
3397 | public ulong F64 { | ||
3398 | get { return result.F64; } | ||
3399 | set { SetF64(value); } | ||
3400 | } | ||
3401 | [global::System.CLSCompliant(false)] | ||
3402 | public Builder SetF64(ulong value) { | ||
3403 | result.hasF64 = true; | ||
3404 | result.f64_ = value; | ||
3405 | return this; | ||
3406 | } | ||
3407 | public Builder ClearF64() { | ||
3408 | result.hasF64 = false; | ||
3409 | result.f64_ = 0UL; | ||
3410 | return this; | ||
3411 | } | ||
3412 | |||
3413 | public pbc::IPopsicleList<float> BsfList { | ||
3414 | get { return result.bsf_; } | ||
3415 | } | ||
3416 | public int BsfCount { | ||
3417 | get { return result.BsfCount; } | ||
3418 | } | ||
3419 | public float GetBsf(int index) { | ||
3420 | return result.GetBsf(index); | ||
3421 | } | ||
3422 | public Builder SetBsf(int index, float value) { | ||
3423 | result.bsf_[index] = value; | ||
3424 | return this; | ||
3425 | } | ||
3426 | public Builder AddBsf(float value) { | ||
3427 | result.bsf_.Add(value); | ||
3428 | return this; | ||
3429 | } | ||
3430 | public Builder AddRangeBsf(scg::IEnumerable<float> values) { | ||
3431 | base.AddRange(values, result.bsf_); | ||
3432 | return this; | ||
3433 | } | ||
3434 | public Builder ClearBsf() { | ||
3435 | result.bsf_.Clear(); | ||
3436 | return this; | ||
3437 | } | ||
3438 | |||
3439 | public pbc::IPopsicleList<double> BsdList { | ||
3440 | get { return result.bsd_; } | ||
3441 | } | ||
3442 | public int BsdCount { | ||
3443 | get { return result.BsdCount; } | ||
3444 | } | ||
3445 | public double GetBsd(int index) { | ||
3446 | return result.GetBsd(index); | ||
3447 | } | ||
3448 | public Builder SetBsd(int index, double value) { | ||
3449 | result.bsd_[index] = value; | ||
3450 | return this; | ||
3451 | } | ||
3452 | public Builder AddBsd(double value) { | ||
3453 | result.bsd_.Add(value); | ||
3454 | return this; | ||
3455 | } | ||
3456 | public Builder AddRangeBsd(scg::IEnumerable<double> values) { | ||
3457 | base.AddRange(values, result.bsd_); | ||
3458 | return this; | ||
3459 | } | ||
3460 | public Builder ClearBsd() { | ||
3461 | result.bsd_.Clear(); | ||
3462 | return this; | ||
3463 | } | ||
3464 | |||
3465 | public pbc::IPopsicleList<float> BbfList { | ||
3466 | get { return result.bbf_; } | ||
3467 | } | ||
3468 | public int BbfCount { | ||
3469 | get { return result.BbfCount; } | ||
3470 | } | ||
3471 | public float GetBbf(int index) { | ||
3472 | return result.GetBbf(index); | ||
3473 | } | ||
3474 | public Builder SetBbf(int index, float value) { | ||
3475 | result.bbf_[index] = value; | ||
3476 | return this; | ||
3477 | } | ||
3478 | public Builder AddBbf(float value) { | ||
3479 | result.bbf_.Add(value); | ||
3480 | return this; | ||
3481 | } | ||
3482 | public Builder AddRangeBbf(scg::IEnumerable<float> values) { | ||
3483 | base.AddRange(values, result.bbf_); | ||
3484 | return this; | ||
3485 | } | ||
3486 | public Builder ClearBbf() { | ||
3487 | result.bbf_.Clear(); | ||
3488 | return this; | ||
3489 | } | ||
3490 | |||
3491 | public pbc::IPopsicleList<double> BbdList { | ||
3492 | get { return result.bbd_; } | ||
3493 | } | ||
3494 | public int BbdCount { | ||
3495 | get { return result.BbdCount; } | ||
3496 | } | ||
3497 | public double GetBbd(int index) { | ||
3498 | return result.GetBbd(index); | ||
3499 | } | ||
3500 | public Builder SetBbd(int index, double value) { | ||
3501 | result.bbd_[index] = value; | ||
3502 | return this; | ||
3503 | } | ||
3504 | public Builder AddBbd(double value) { | ||
3505 | result.bbd_.Add(value); | ||
3506 | return this; | ||
3507 | } | ||
3508 | public Builder AddRangeBbd(scg::IEnumerable<double> values) { | ||
3509 | base.AddRange(values, result.bbd_); | ||
3510 | return this; | ||
3511 | } | ||
3512 | public Builder ClearBbd() { | ||
3513 | result.bbd_.Clear(); | ||
3514 | return this; | ||
3515 | } | ||
3516 | |||
3517 | public bool HasE32 { | ||
3518 | get { return result.HasE32; } | ||
3519 | } | ||
3520 | public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 E32 { | ||
3521 | get { return result.E32; } | ||
3522 | set { SetE32(value); } | ||
3523 | } | ||
3524 | public Builder SetE32(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 value) { | ||
3525 | result.hasE32 = true; | ||
3526 | result.e32_ = value; | ||
3527 | return this; | ||
3528 | } | ||
3529 | public Builder ClearE32() { | ||
3530 | result.hasE32 = false; | ||
3531 | result.e32_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1; | ||
3532 | return this; | ||
3533 | } | ||
3534 | |||
3535 | public bool HasSubmes { | ||
3536 | get { return result.HasSubmes; } | ||
3537 | } | ||
3538 | public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage Submes { | ||
3539 | get { return result.Submes; } | ||
3540 | set { SetSubmes(value); } | ||
3541 | } | ||
3542 | public Builder SetSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { | ||
3543 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3544 | result.hasSubmes = true; | ||
3545 | result.submes_ = value; | ||
3546 | return this; | ||
3547 | } | ||
3548 | public Builder SetSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) { | ||
3549 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3550 | result.hasSubmes = true; | ||
3551 | result.submes_ = builderForValue.Build(); | ||
3552 | return this; | ||
3553 | } | ||
3554 | public Builder MergeSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { | ||
3555 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3556 | if (result.HasSubmes && | ||
3557 | result.submes_ != global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance) { | ||
3558 | result.submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder(result.submes_).MergeFrom(value).BuildPartial(); | ||
3559 | } else { | ||
3560 | result.submes_ = value; | ||
3561 | } | ||
3562 | result.hasSubmes = true; | ||
3563 | return this; | ||
3564 | } | ||
3565 | public Builder ClearSubmes() { | ||
3566 | result.hasSubmes = false; | ||
3567 | result.submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance; | ||
3568 | return this; | ||
3569 | } | ||
3570 | |||
3571 | public pbc::IPopsicleList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> SubmessersList { | ||
3572 | get { return result.submessers_; } | ||
3573 | } | ||
3574 | public int SubmessersCount { | ||
3575 | get { return result.SubmessersCount; } | ||
3576 | } | ||
3577 | public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage GetSubmessers(int index) { | ||
3578 | return result.GetSubmessers(index); | ||
3579 | } | ||
3580 | public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { | ||
3581 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3582 | result.submessers_[index] = value; | ||
3583 | return this; | ||
3584 | } | ||
3585 | public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) { | ||
3586 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3587 | result.submessers_[index] = builderForValue.Build(); | ||
3588 | return this; | ||
3589 | } | ||
3590 | public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) { | ||
3591 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3592 | result.submessers_.Add(value); | ||
3593 | return this; | ||
3594 | } | ||
3595 | public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) { | ||
3596 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3597 | result.submessers_.Add(builderForValue.Build()); | ||
3598 | return this; | ||
3599 | } | ||
3600 | public Builder AddRangeSubmessers(scg::IEnumerable<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> values) { | ||
3601 | base.AddRange(values, result.submessers_); | ||
3602 | return this; | ||
3603 | } | ||
3604 | public Builder ClearSubmessers() { | ||
3605 | result.submessers_.Clear(); | ||
3606 | return this; | ||
3607 | } | ||
3608 | |||
3609 | public bool HasSha { | ||
3610 | get { return result.HasSha; } | ||
3611 | } | ||
3612 | public pb::ByteString Sha { | ||
3613 | get { return result.Sha; } | ||
3614 | set { SetSha(value); } | ||
3615 | } | ||
3616 | public Builder SetSha(pb::ByteString value) { | ||
3617 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3618 | result.hasSha = true; | ||
3619 | result.sha_ = value; | ||
3620 | return this; | ||
3621 | } | ||
3622 | public Builder ClearSha() { | ||
3623 | result.hasSha = false; | ||
3624 | result.sha_ = pb::ByteString.Empty; | ||
3625 | return this; | ||
3626 | } | ||
3627 | |||
3628 | public pbc::IPopsicleList<pb::ByteString> ShasList { | ||
3629 | get { return result.shas_; } | ||
3630 | } | ||
3631 | public int ShasCount { | ||
3632 | get { return result.ShasCount; } | ||
3633 | } | ||
3634 | public pb::ByteString GetShas(int index) { | ||
3635 | return result.GetShas(index); | ||
3636 | } | ||
3637 | public Builder SetShas(int index, pb::ByteString value) { | ||
3638 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3639 | result.shas_[index] = value; | ||
3640 | return this; | ||
3641 | } | ||
3642 | public Builder AddShas(pb::ByteString value) { | ||
3643 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3644 | result.shas_.Add(value); | ||
3645 | return this; | ||
3646 | } | ||
3647 | public Builder AddRangeShas(scg::IEnumerable<pb::ByteString> values) { | ||
3648 | base.AddRange(values, result.shas_); | ||
3649 | return this; | ||
3650 | } | ||
3651 | public Builder ClearShas() { | ||
3652 | result.shas_.Clear(); | ||
3653 | return this; | ||
3654 | } | ||
3655 | |||
3656 | public bool HasExtmes { | ||
3657 | get { return result.HasExtmes; } | ||
3658 | } | ||
3659 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmes { | ||
3660 | get { return result.Extmes; } | ||
3661 | set { SetExtmes(value); } | ||
3662 | } | ||
3663 | public Builder SetExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { | ||
3664 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3665 | result.hasExtmes = true; | ||
3666 | result.extmes_ = value; | ||
3667 | return this; | ||
3668 | } | ||
3669 | public Builder SetExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { | ||
3670 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3671 | result.hasExtmes = true; | ||
3672 | result.extmes_ = builderForValue.Build(); | ||
3673 | return this; | ||
3674 | } | ||
3675 | public Builder MergeExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { | ||
3676 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3677 | if (result.HasExtmes && | ||
3678 | result.extmes_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) { | ||
3679 | result.extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(result.extmes_).MergeFrom(value).BuildPartial(); | ||
3680 | } else { | ||
3681 | result.extmes_ = value; | ||
3682 | } | ||
3683 | result.hasExtmes = true; | ||
3684 | return this; | ||
3685 | } | ||
3686 | public Builder ClearExtmes() { | ||
3687 | result.hasExtmes = false; | ||
3688 | result.extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; | ||
3689 | return this; | ||
3690 | } | ||
3691 | |||
3692 | public pbc::IPopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage> ExtmessersList { | ||
3693 | get { return result.extmessers_; } | ||
3694 | } | ||
3695 | public int ExtmessersCount { | ||
3696 | get { return result.ExtmessersCount; } | ||
3697 | } | ||
3698 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage GetExtmessers(int index) { | ||
3699 | return result.GetExtmessers(index); | ||
3700 | } | ||
3701 | public Builder SetExtmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { | ||
3702 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3703 | result.extmessers_[index] = value; | ||
3704 | return this; | ||
3705 | } | ||
3706 | public Builder SetExtmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { | ||
3707 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3708 | result.extmessers_[index] = builderForValue.Build(); | ||
3709 | return this; | ||
3710 | } | ||
3711 | public Builder AddExtmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { | ||
3712 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3713 | result.extmessers_.Add(value); | ||
3714 | return this; | ||
3715 | } | ||
3716 | public Builder AddExtmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { | ||
3717 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3718 | result.extmessers_.Add(builderForValue.Build()); | ||
3719 | return this; | ||
3720 | } | ||
3721 | public Builder AddRangeExtmessers(scg::IEnumerable<global::Sirikata.PB._PBJ_Internal.ExternalMessage> values) { | ||
3722 | base.AddRange(values, result.extmessers_); | ||
3723 | return this; | ||
3724 | } | ||
3725 | public Builder ClearExtmessers() { | ||
3726 | result.extmessers_.Clear(); | ||
3727 | return this; | ||
3728 | } | ||
3729 | |||
3730 | public bool HasExtmesser { | ||
3731 | get { return result.HasExtmesser; } | ||
3732 | } | ||
3733 | public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmesser { | ||
3734 | get { return result.Extmesser; } | ||
3735 | set { SetExtmesser(value); } | ||
3736 | } | ||
3737 | public Builder SetExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { | ||
3738 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3739 | result.hasExtmesser = true; | ||
3740 | result.extmesser_ = value; | ||
3741 | return this; | ||
3742 | } | ||
3743 | public Builder SetExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) { | ||
3744 | pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | ||
3745 | result.hasExtmesser = true; | ||
3746 | result.extmesser_ = builderForValue.Build(); | ||
3747 | return this; | ||
3748 | } | ||
3749 | public Builder MergeExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) { | ||
3750 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
3751 | if (result.HasExtmesser && | ||
3752 | result.extmesser_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) { | ||
3753 | result.extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(result.extmesser_).MergeFrom(value).BuildPartial(); | ||
3754 | } else { | ||
3755 | result.extmesser_ = value; | ||
3756 | } | ||
3757 | result.hasExtmesser = true; | ||
3758 | return this; | ||
3759 | } | ||
3760 | public Builder ClearExtmesser() { | ||
3761 | result.hasExtmesser = false; | ||
3762 | result.extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; | ||
3763 | return this; | ||
3764 | } | ||
3765 | } | ||
3766 | static TestMessage() { | ||
3767 | object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null); | ||
3768 | } | ||
3769 | } | ||
3770 | |||
3771 | #endregion | ||
3772 | |||
3773 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs deleted file mode 100644 index bcd02fa..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs +++ /dev/null | |||
@@ -1,1761 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace Sirikata.PB { | ||
31 | public class ExternalMessage : PBJ.IMessage { | ||
32 | protected _PBJ_Internal.ExternalMessage super; | ||
33 | public _PBJ_Internal.ExternalMessage _PBJSuper{ get { return super;} } | ||
34 | public ExternalMessage() { | ||
35 | super=new _PBJ_Internal.ExternalMessage(); | ||
36 | } | ||
37 | public ExternalMessage(_PBJ_Internal.ExternalMessage reference) { | ||
38 | super=reference; | ||
39 | } | ||
40 | public static ExternalMessage defaultInstance= new ExternalMessage (_PBJ_Internal.ExternalMessage.DefaultInstance); | ||
41 | public static ExternalMessage DefaultInstance{ | ||
42 | get {return defaultInstance;} | ||
43 | } | ||
44 | public static pbd.MessageDescriptor Descriptor { | ||
45 | get { return _PBJ_Internal.ExternalMessage.Descriptor; } } | ||
46 | public static class Types { | ||
47 | public class SubMessage : PBJ.IMessage { | ||
48 | protected _PBJ_Internal.ExternalMessage.Types.SubMessage super; | ||
49 | public _PBJ_Internal.ExternalMessage.Types.SubMessage _PBJSuper{ get { return super;} } | ||
50 | public SubMessage() { | ||
51 | super=new _PBJ_Internal.ExternalMessage.Types.SubMessage(); | ||
52 | } | ||
53 | public SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage reference) { | ||
54 | super=reference; | ||
55 | } | ||
56 | public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance); | ||
57 | public static SubMessage DefaultInstance{ | ||
58 | get {return defaultInstance;} | ||
59 | } | ||
60 | public static pbd.MessageDescriptor Descriptor { | ||
61 | get { return _PBJ_Internal.ExternalMessage.Types.SubMessage.Descriptor; } } | ||
62 | public static class Types { | ||
63 | } | ||
64 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
65 | return false; | ||
66 | } | ||
67 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
68 | return false; | ||
69 | } | ||
70 | public const int SubuuidFieldTag=1; | ||
71 | public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } | ||
72 | public PBJ.UUID Subuuid{ get { | ||
73 | if (HasSubuuid) { | ||
74 | return PBJ._PBJ.CastUuid(super.Subuuid); | ||
75 | } else { | ||
76 | return PBJ._PBJ.CastUuid(); | ||
77 | } | ||
78 | } | ||
79 | } | ||
80 | public const int SubvectorFieldTag=2; | ||
81 | public bool HasSubvector{ get {return super.SubvectorCount>=3;} } | ||
82 | public PBJ.Vector3d Subvector{ get { | ||
83 | int index=0; | ||
84 | if (HasSubvector) { | ||
85 | return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); | ||
86 | } else { | ||
87 | return PBJ._PBJ.CastVector3d(); | ||
88 | } | ||
89 | } | ||
90 | } | ||
91 | public const int SubdurationFieldTag=3; | ||
92 | public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } | ||
93 | public PBJ.Duration Subduration{ get { | ||
94 | if (HasSubduration) { | ||
95 | return PBJ._PBJ.CastDuration(super.Subduration); | ||
96 | } else { | ||
97 | return PBJ._PBJ.CastDuration(); | ||
98 | } | ||
99 | } | ||
100 | } | ||
101 | public const int SubnormalFieldTag=4; | ||
102 | public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } | ||
103 | public PBJ.Vector3f Subnormal{ get { | ||
104 | int index=0; | ||
105 | if (HasSubnormal) { | ||
106 | return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); | ||
107 | } else { | ||
108 | return PBJ._PBJ.CastNormal(); | ||
109 | } | ||
110 | } | ||
111 | } | ||
112 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
113 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
114 | public static Builder CreateBuilder() { return new Builder(); } | ||
115 | public static Builder CreateBuilder(SubMessage prototype) { | ||
116 | return (Builder)new Builder().MergeFrom(prototype); | ||
117 | } | ||
118 | public static SubMessage ParseFrom(pb::ByteString data) { | ||
119 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); | ||
120 | } | ||
121 | public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
122 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); | ||
123 | } | ||
124 | public static SubMessage ParseFrom(byte[] data) { | ||
125 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); | ||
126 | } | ||
127 | public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
128 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); | ||
129 | } | ||
130 | public static SubMessage ParseFrom(global::System.IO.Stream data) { | ||
131 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); | ||
132 | } | ||
133 | public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
134 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); | ||
135 | } | ||
136 | public static SubMessage ParseFrom(pb::CodedInputStream data) { | ||
137 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data)); | ||
138 | } | ||
139 | public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
140 | return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er)); | ||
141 | } | ||
142 | protected override bool _HasAllPBJFields{ get { | ||
143 | return true | ||
144 | ; | ||
145 | } } | ||
146 | public bool IsInitialized { get { | ||
147 | return super.IsInitialized&&_HasAllPBJFields; | ||
148 | } } | ||
149 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
150 | protected override bool _HasAllPBJFields{ get { | ||
151 | return true | ||
152 | ; | ||
153 | } } | ||
154 | public bool IsInitialized { get { | ||
155 | return super.IsInitialized&&_HasAllPBJFields; | ||
156 | } } | ||
157 | protected _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder super; | ||
158 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
159 | public _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} } | ||
160 | public Builder() {super = new _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder();} | ||
161 | public Builder(_PBJ_Internal.ExternalMessage.Types.SubMessage.Builder other) { | ||
162 | super=other; | ||
163 | } | ||
164 | public Builder Clone() {return new Builder(super.Clone());} | ||
165 | public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
166 | public Builder Clear() {super.Clear();return this;} | ||
167 | public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());} | ||
168 | public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;} | ||
169 | public pbd::MessageDescriptor DescriptorForType { | ||
170 | get { return SubMessage.Descriptor; } } | ||
171 | public Builder ClearSubuuid() { super.ClearSubuuid();return this;} | ||
172 | public const int SubuuidFieldTag=1; | ||
173 | public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } | ||
174 | public PBJ.UUID Subuuid{ get { | ||
175 | if (HasSubuuid) { | ||
176 | return PBJ._PBJ.CastUuid(super.Subuuid); | ||
177 | } else { | ||
178 | return PBJ._PBJ.CastUuid(); | ||
179 | } | ||
180 | } | ||
181 | set { | ||
182 | super.Subuuid=(PBJ._PBJ.Construct(value)); | ||
183 | } | ||
184 | } | ||
185 | public Builder ClearSubvector() { super.ClearSubvector();return this;} | ||
186 | public const int SubvectorFieldTag=2; | ||
187 | public bool HasSubvector{ get {return super.SubvectorCount>=3;} } | ||
188 | public PBJ.Vector3d Subvector{ get { | ||
189 | int index=0; | ||
190 | if (HasSubvector) { | ||
191 | return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); | ||
192 | } else { | ||
193 | return PBJ._PBJ.CastVector3d(); | ||
194 | } | ||
195 | } | ||
196 | set { | ||
197 | super.ClearSubvector(); | ||
198 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
199 | super.AddSubvector(_PBJtempArray[0]); | ||
200 | super.AddSubvector(_PBJtempArray[1]); | ||
201 | super.AddSubvector(_PBJtempArray[2]); | ||
202 | } | ||
203 | } | ||
204 | public Builder ClearSubduration() { super.ClearSubduration();return this;} | ||
205 | public const int SubdurationFieldTag=3; | ||
206 | public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } | ||
207 | public PBJ.Duration Subduration{ get { | ||
208 | if (HasSubduration) { | ||
209 | return PBJ._PBJ.CastDuration(super.Subduration); | ||
210 | } else { | ||
211 | return PBJ._PBJ.CastDuration(); | ||
212 | } | ||
213 | } | ||
214 | set { | ||
215 | super.Subduration=(PBJ._PBJ.Construct(value)); | ||
216 | } | ||
217 | } | ||
218 | public Builder ClearSubnormal() { super.ClearSubnormal();return this;} | ||
219 | public const int SubnormalFieldTag=4; | ||
220 | public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } | ||
221 | public PBJ.Vector3f Subnormal{ get { | ||
222 | int index=0; | ||
223 | if (HasSubnormal) { | ||
224 | return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); | ||
225 | } else { | ||
226 | return PBJ._PBJ.CastNormal(); | ||
227 | } | ||
228 | } | ||
229 | set { | ||
230 | super.ClearSubnormal(); | ||
231 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
232 | super.AddSubnormal(_PBJtempArray[0]); | ||
233 | super.AddSubnormal(_PBJtempArray[1]); | ||
234 | } | ||
235 | } | ||
236 | } | ||
237 | } | ||
238 | } | ||
239 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
240 | return false; | ||
241 | } | ||
242 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
243 | return false; | ||
244 | } | ||
245 | public const int IsTrueFieldTag=40; | ||
246 | public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} } | ||
247 | public bool IsTrue{ get { | ||
248 | if (HasIsTrue) { | ||
249 | return PBJ._PBJ.CastBool(super.IsTrue); | ||
250 | } else { | ||
251 | return true; | ||
252 | } | ||
253 | } | ||
254 | } | ||
255 | public const int V2FFieldTag=2; | ||
256 | public bool HasV2F{ get {return super.V2FCount>=2;} } | ||
257 | public PBJ.Vector2f V2F{ get { | ||
258 | int index=0; | ||
259 | if (HasV2F) { | ||
260 | return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); | ||
261 | } else { | ||
262 | return PBJ._PBJ.CastVector2f(); | ||
263 | } | ||
264 | } | ||
265 | } | ||
266 | public const int SubMesFieldTag=30; | ||
267 | public bool HasSubMes{ get {return super.HasSubMes;} } | ||
268 | public Types.SubMessage SubMes{ get { | ||
269 | if (HasSubMes) { | ||
270 | return new Types.SubMessage(super.SubMes); | ||
271 | } else { | ||
272 | return new Types.SubMessage(); | ||
273 | } | ||
274 | } | ||
275 | } | ||
276 | public const int SubmessersFieldTag=31; | ||
277 | public int SubmessersCount { get { return super.SubmessersCount;} } | ||
278 | public bool HasSubmessers(int index) {return true;} | ||
279 | public Types.SubMessage Submessers(int index) { | ||
280 | return new Types.SubMessage(super.GetSubmessers(index)); | ||
281 | } | ||
282 | public const int ShaFieldTag=32; | ||
283 | public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } | ||
284 | public PBJ.SHA256 Sha{ get { | ||
285 | if (HasSha) { | ||
286 | return PBJ._PBJ.CastSha256(super.Sha); | ||
287 | } else { | ||
288 | return PBJ._PBJ.CastSha256(); | ||
289 | } | ||
290 | } | ||
291 | } | ||
292 | public const int ShasFieldTag=33; | ||
293 | public int ShasCount { get { return super.ShasCount;} } | ||
294 | public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} | ||
295 | public PBJ.SHA256 Shas(int index) { | ||
296 | return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); | ||
297 | } | ||
298 | public const int V3FFieldTag=4; | ||
299 | public bool HasV3F{ get {return super.V3FCount>=3;} } | ||
300 | public PBJ.Vector3f V3F{ get { | ||
301 | int index=0; | ||
302 | if (HasV3F) { | ||
303 | return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); | ||
304 | } else { | ||
305 | return PBJ._PBJ.CastVector3f(); | ||
306 | } | ||
307 | } | ||
308 | } | ||
309 | public const int V3FfFieldTag=5; | ||
310 | public int V3FfCount { get { return super.V3FfCount/3;} } | ||
311 | public bool HasV3Ff(int index) { return true; } | ||
312 | public PBJ.Vector3f GetV3Ff(int index) { | ||
313 | if (HasV3Ff(index)) { | ||
314 | return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2)); | ||
315 | } else { | ||
316 | return PBJ._PBJ.CastVector3f(); | ||
317 | } | ||
318 | } | ||
319 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
320 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
321 | public static Builder CreateBuilder() { return new Builder(); } | ||
322 | public static Builder CreateBuilder(ExternalMessage prototype) { | ||
323 | return (Builder)new Builder().MergeFrom(prototype); | ||
324 | } | ||
325 | public static ExternalMessage ParseFrom(pb::ByteString data) { | ||
326 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); | ||
327 | } | ||
328 | public static ExternalMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
329 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); | ||
330 | } | ||
331 | public static ExternalMessage ParseFrom(byte[] data) { | ||
332 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); | ||
333 | } | ||
334 | public static ExternalMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
335 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); | ||
336 | } | ||
337 | public static ExternalMessage ParseFrom(global::System.IO.Stream data) { | ||
338 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); | ||
339 | } | ||
340 | public static ExternalMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
341 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); | ||
342 | } | ||
343 | public static ExternalMessage ParseFrom(pb::CodedInputStream data) { | ||
344 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data)); | ||
345 | } | ||
346 | public static ExternalMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
347 | return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er)); | ||
348 | } | ||
349 | protected override bool _HasAllPBJFields{ get { | ||
350 | return true | ||
351 | &&HasV3F | ||
352 | ; | ||
353 | } } | ||
354 | public bool IsInitialized { get { | ||
355 | return super.IsInitialized&&_HasAllPBJFields; | ||
356 | } } | ||
357 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
358 | protected override bool _HasAllPBJFields{ get { | ||
359 | return true | ||
360 | &&HasV3F | ||
361 | ; | ||
362 | } } | ||
363 | public bool IsInitialized { get { | ||
364 | return super.IsInitialized&&_HasAllPBJFields; | ||
365 | } } | ||
366 | protected _PBJ_Internal.ExternalMessage.Builder super; | ||
367 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
368 | public _PBJ_Internal.ExternalMessage.Builder _PBJSuper{ get { return super;} } | ||
369 | public Builder() {super = new _PBJ_Internal.ExternalMessage.Builder();} | ||
370 | public Builder(_PBJ_Internal.ExternalMessage.Builder other) { | ||
371 | super=other; | ||
372 | } | ||
373 | public Builder Clone() {return new Builder(super.Clone());} | ||
374 | public Builder MergeFrom(ExternalMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
375 | public Builder Clear() {super.Clear();return this;} | ||
376 | public ExternalMessage BuildPartial() {return new ExternalMessage(super.BuildPartial());} | ||
377 | public ExternalMessage Build() {if (_HasAllPBJFields) return new ExternalMessage(super.Build());return null;} | ||
378 | public pbd::MessageDescriptor DescriptorForType { | ||
379 | get { return ExternalMessage.Descriptor; } } | ||
380 | public Builder ClearIsTrue() { super.ClearIsTrue();return this;} | ||
381 | public const int IsTrueFieldTag=40; | ||
382 | public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} } | ||
383 | public bool IsTrue{ get { | ||
384 | if (HasIsTrue) { | ||
385 | return PBJ._PBJ.CastBool(super.IsTrue); | ||
386 | } else { | ||
387 | return true; | ||
388 | } | ||
389 | } | ||
390 | set { | ||
391 | super.IsTrue=(PBJ._PBJ.Construct(value)); | ||
392 | } | ||
393 | } | ||
394 | public Builder ClearV2F() { super.ClearV2F();return this;} | ||
395 | public const int V2FFieldTag=2; | ||
396 | public bool HasV2F{ get {return super.V2FCount>=2;} } | ||
397 | public PBJ.Vector2f V2F{ get { | ||
398 | int index=0; | ||
399 | if (HasV2F) { | ||
400 | return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); | ||
401 | } else { | ||
402 | return PBJ._PBJ.CastVector2f(); | ||
403 | } | ||
404 | } | ||
405 | set { | ||
406 | super.ClearV2F(); | ||
407 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value); | ||
408 | super.AddV2F(_PBJtempArray[0]); | ||
409 | super.AddV2F(_PBJtempArray[1]); | ||
410 | } | ||
411 | } | ||
412 | public Builder ClearSubMes() { super.ClearSubMes();return this;} | ||
413 | public const int SubMesFieldTag=30; | ||
414 | public bool HasSubMes{ get {return super.HasSubMes;} } | ||
415 | public Types.SubMessage SubMes{ get { | ||
416 | if (HasSubMes) { | ||
417 | return new Types.SubMessage(super.SubMes); | ||
418 | } else { | ||
419 | return new Types.SubMessage(); | ||
420 | } | ||
421 | } | ||
422 | set { | ||
423 | super.SubMes=value._PBJSuper; | ||
424 | } | ||
425 | } | ||
426 | public Builder ClearSubmessers() { super.ClearSubmessers();return this;} | ||
427 | public Builder SetSubmessers(int index,Types.SubMessage value) { | ||
428 | super.SetSubmessers(index,value._PBJSuper); | ||
429 | return this; | ||
430 | } | ||
431 | public const int SubmessersFieldTag=31; | ||
432 | public int SubmessersCount { get { return super.SubmessersCount;} } | ||
433 | public bool HasSubmessers(int index) {return true;} | ||
434 | public Types.SubMessage Submessers(int index) { | ||
435 | return new Types.SubMessage(super.GetSubmessers(index)); | ||
436 | } | ||
437 | public Builder AddSubmessers(Types.SubMessage value) { | ||
438 | super.AddSubmessers(value._PBJSuper); | ||
439 | return this; | ||
440 | } | ||
441 | public Builder ClearSha() { super.ClearSha();return this;} | ||
442 | public const int ShaFieldTag=32; | ||
443 | public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } | ||
444 | public PBJ.SHA256 Sha{ get { | ||
445 | if (HasSha) { | ||
446 | return PBJ._PBJ.CastSha256(super.Sha); | ||
447 | } else { | ||
448 | return PBJ._PBJ.CastSha256(); | ||
449 | } | ||
450 | } | ||
451 | set { | ||
452 | super.Sha=(PBJ._PBJ.Construct(value)); | ||
453 | } | ||
454 | } | ||
455 | public Builder ClearShas() { super.ClearShas();return this;} | ||
456 | public Builder SetShas(int index, PBJ.SHA256 value) { | ||
457 | super.SetShas(index,PBJ._PBJ.Construct(value)); | ||
458 | return this; | ||
459 | } | ||
460 | public const int ShasFieldTag=33; | ||
461 | public int ShasCount { get { return super.ShasCount;} } | ||
462 | public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} | ||
463 | public PBJ.SHA256 Shas(int index) { | ||
464 | return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); | ||
465 | } | ||
466 | public Builder AddShas(PBJ.SHA256 value) { | ||
467 | super.AddShas(PBJ._PBJ.Construct(value)); | ||
468 | return this; | ||
469 | } | ||
470 | public Builder ClearV3F() { super.ClearV3F();return this;} | ||
471 | public const int V3FFieldTag=4; | ||
472 | public bool HasV3F{ get {return super.V3FCount>=3;} } | ||
473 | public PBJ.Vector3f V3F{ get { | ||
474 | int index=0; | ||
475 | if (HasV3F) { | ||
476 | return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); | ||
477 | } else { | ||
478 | return PBJ._PBJ.CastVector3f(); | ||
479 | } | ||
480 | } | ||
481 | set { | ||
482 | super.ClearV3F(); | ||
483 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
484 | super.AddV3F(_PBJtempArray[0]); | ||
485 | super.AddV3F(_PBJtempArray[1]); | ||
486 | super.AddV3F(_PBJtempArray[2]); | ||
487 | } | ||
488 | } | ||
489 | public Builder ClearV3Ff() { super.ClearV3Ff();return this;} | ||
490 | public const int V3FfFieldTag=5; | ||
491 | public int V3FfCount { get { return super.V3FfCount/3;} } | ||
492 | public bool HasV3Ff(int index) { return true; } | ||
493 | public PBJ.Vector3f GetV3Ff(int index) { | ||
494 | if (HasV3Ff(index)) { | ||
495 | return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2)); | ||
496 | } else { | ||
497 | return PBJ._PBJ.CastVector3f(); | ||
498 | } | ||
499 | } | ||
500 | public Builder AddV3Ff(PBJ.Vector3f value) { | ||
501 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
502 | super.AddV3Ff(_PBJtempArray[0]); | ||
503 | super.AddV3Ff(_PBJtempArray[1]); | ||
504 | super.AddV3Ff(_PBJtempArray[2]); | ||
505 | return this; | ||
506 | } | ||
507 | public Builder SetV3Ff(int index,PBJ.Vector3f value) { | ||
508 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
509 | super.SetV3Ff(index*3+0,_PBJtempArray[0]); | ||
510 | super.SetV3Ff(index*3+1,_PBJtempArray[1]); | ||
511 | super.SetV3Ff(index*3+2,_PBJtempArray[2]); | ||
512 | return this; | ||
513 | } | ||
514 | } | ||
515 | } | ||
516 | } | ||
517 | namespace Sirikata.PB { | ||
518 | public class TestMessage : PBJ.IMessage { | ||
519 | protected _PBJ_Internal.TestMessage super; | ||
520 | public _PBJ_Internal.TestMessage _PBJSuper{ get { return super;} } | ||
521 | public TestMessage() { | ||
522 | super=new _PBJ_Internal.TestMessage(); | ||
523 | } | ||
524 | public TestMessage(_PBJ_Internal.TestMessage reference) { | ||
525 | super=reference; | ||
526 | } | ||
527 | public static TestMessage defaultInstance= new TestMessage (_PBJ_Internal.TestMessage.DefaultInstance); | ||
528 | public static TestMessage DefaultInstance{ | ||
529 | get {return defaultInstance;} | ||
530 | } | ||
531 | public static pbd.MessageDescriptor Descriptor { | ||
532 | get { return _PBJ_Internal.TestMessage.Descriptor; } } | ||
533 | public static class Types { | ||
534 | public enum Flagsf32 { | ||
535 | UNIVERSA=_PBJ_Internal.TestMessage.Types.Flagsf32.UNIVERSA, | ||
536 | WE=_PBJ_Internal.TestMessage.Types.Flagsf32.WE, | ||
537 | IMAGE=_PBJ_Internal.TestMessage.Types.Flagsf32.IMAGE, | ||
538 | LOCA=_PBJ_Internal.TestMessage.Types.Flagsf32.LOCA | ||
539 | }; | ||
540 | public enum Flagsf64 { | ||
541 | UNIVERSAL=_PBJ_Internal.TestMessage.Types.Flagsf64.UNIVERSAL, | ||
542 | WEB=_PBJ_Internal.TestMessage.Types.Flagsf64.WEB, | ||
543 | IMAGES=_PBJ_Internal.TestMessage.Types.Flagsf64.IMAGES, | ||
544 | LOCAL=_PBJ_Internal.TestMessage.Types.Flagsf64.LOCAL | ||
545 | }; | ||
546 | public enum Enum32 { | ||
547 | UNIVERSAL1=_PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1, | ||
548 | WEB1=_PBJ_Internal.TestMessage.Types.Enum32.WEB1, | ||
549 | IMAGES1=_PBJ_Internal.TestMessage.Types.Enum32.IMAGES1, | ||
550 | LOCAL1=_PBJ_Internal.TestMessage.Types.Enum32.LOCAL1 | ||
551 | }; | ||
552 | public class SubMessage : PBJ.IMessage { | ||
553 | protected _PBJ_Internal.TestMessage.Types.SubMessage super; | ||
554 | public _PBJ_Internal.TestMessage.Types.SubMessage _PBJSuper{ get { return super;} } | ||
555 | public SubMessage() { | ||
556 | super=new _PBJ_Internal.TestMessage.Types.SubMessage(); | ||
557 | } | ||
558 | public SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage reference) { | ||
559 | super=reference; | ||
560 | } | ||
561 | public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance); | ||
562 | public static SubMessage DefaultInstance{ | ||
563 | get {return defaultInstance;} | ||
564 | } | ||
565 | public static pbd.MessageDescriptor Descriptor { | ||
566 | get { return _PBJ_Internal.TestMessage.Types.SubMessage.Descriptor; } } | ||
567 | public static class Types { | ||
568 | } | ||
569 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
570 | return false; | ||
571 | } | ||
572 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
573 | return false; | ||
574 | } | ||
575 | public const int SubuuidFieldTag=1; | ||
576 | public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } | ||
577 | public PBJ.UUID Subuuid{ get { | ||
578 | if (HasSubuuid) { | ||
579 | return PBJ._PBJ.CastUuid(super.Subuuid); | ||
580 | } else { | ||
581 | return PBJ._PBJ.CastUuid(); | ||
582 | } | ||
583 | } | ||
584 | } | ||
585 | public const int SubvectorFieldTag=2; | ||
586 | public bool HasSubvector{ get {return super.SubvectorCount>=3;} } | ||
587 | public PBJ.Vector3d Subvector{ get { | ||
588 | int index=0; | ||
589 | if (HasSubvector) { | ||
590 | return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); | ||
591 | } else { | ||
592 | return PBJ._PBJ.CastVector3d(); | ||
593 | } | ||
594 | } | ||
595 | } | ||
596 | public const int SubdurationFieldTag=3; | ||
597 | public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } | ||
598 | public PBJ.Duration Subduration{ get { | ||
599 | if (HasSubduration) { | ||
600 | return PBJ._PBJ.CastDuration(super.Subduration); | ||
601 | } else { | ||
602 | return PBJ._PBJ.CastDuration(); | ||
603 | } | ||
604 | } | ||
605 | } | ||
606 | public const int SubnormalFieldTag=4; | ||
607 | public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } | ||
608 | public PBJ.Vector3f Subnormal{ get { | ||
609 | int index=0; | ||
610 | if (HasSubnormal) { | ||
611 | return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); | ||
612 | } else { | ||
613 | return PBJ._PBJ.CastNormal(); | ||
614 | } | ||
615 | } | ||
616 | } | ||
617 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
618 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
619 | public static Builder CreateBuilder() { return new Builder(); } | ||
620 | public static Builder CreateBuilder(SubMessage prototype) { | ||
621 | return (Builder)new Builder().MergeFrom(prototype); | ||
622 | } | ||
623 | public static SubMessage ParseFrom(pb::ByteString data) { | ||
624 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); | ||
625 | } | ||
626 | public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
627 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); | ||
628 | } | ||
629 | public static SubMessage ParseFrom(byte[] data) { | ||
630 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); | ||
631 | } | ||
632 | public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
633 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); | ||
634 | } | ||
635 | public static SubMessage ParseFrom(global::System.IO.Stream data) { | ||
636 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); | ||
637 | } | ||
638 | public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
639 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); | ||
640 | } | ||
641 | public static SubMessage ParseFrom(pb::CodedInputStream data) { | ||
642 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data)); | ||
643 | } | ||
644 | public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
645 | return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er)); | ||
646 | } | ||
647 | protected override bool _HasAllPBJFields{ get { | ||
648 | return true | ||
649 | ; | ||
650 | } } | ||
651 | public bool IsInitialized { get { | ||
652 | return super.IsInitialized&&_HasAllPBJFields; | ||
653 | } } | ||
654 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
655 | protected override bool _HasAllPBJFields{ get { | ||
656 | return true | ||
657 | ; | ||
658 | } } | ||
659 | public bool IsInitialized { get { | ||
660 | return super.IsInitialized&&_HasAllPBJFields; | ||
661 | } } | ||
662 | protected _PBJ_Internal.TestMessage.Types.SubMessage.Builder super; | ||
663 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
664 | public _PBJ_Internal.TestMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} } | ||
665 | public Builder() {super = new _PBJ_Internal.TestMessage.Types.SubMessage.Builder();} | ||
666 | public Builder(_PBJ_Internal.TestMessage.Types.SubMessage.Builder other) { | ||
667 | super=other; | ||
668 | } | ||
669 | public Builder Clone() {return new Builder(super.Clone());} | ||
670 | public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
671 | public Builder Clear() {super.Clear();return this;} | ||
672 | public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());} | ||
673 | public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;} | ||
674 | public pbd::MessageDescriptor DescriptorForType { | ||
675 | get { return SubMessage.Descriptor; } } | ||
676 | public Builder ClearSubuuid() { super.ClearSubuuid();return this;} | ||
677 | public const int SubuuidFieldTag=1; | ||
678 | public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} } | ||
679 | public PBJ.UUID Subuuid{ get { | ||
680 | if (HasSubuuid) { | ||
681 | return PBJ._PBJ.CastUuid(super.Subuuid); | ||
682 | } else { | ||
683 | return PBJ._PBJ.CastUuid(); | ||
684 | } | ||
685 | } | ||
686 | set { | ||
687 | super.Subuuid=(PBJ._PBJ.Construct(value)); | ||
688 | } | ||
689 | } | ||
690 | public Builder ClearSubvector() { super.ClearSubvector();return this;} | ||
691 | public const int SubvectorFieldTag=2; | ||
692 | public bool HasSubvector{ get {return super.SubvectorCount>=3;} } | ||
693 | public PBJ.Vector3d Subvector{ get { | ||
694 | int index=0; | ||
695 | if (HasSubvector) { | ||
696 | return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2)); | ||
697 | } else { | ||
698 | return PBJ._PBJ.CastVector3d(); | ||
699 | } | ||
700 | } | ||
701 | set { | ||
702 | super.ClearSubvector(); | ||
703 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
704 | super.AddSubvector(_PBJtempArray[0]); | ||
705 | super.AddSubvector(_PBJtempArray[1]); | ||
706 | super.AddSubvector(_PBJtempArray[2]); | ||
707 | } | ||
708 | } | ||
709 | public Builder ClearSubduration() { super.ClearSubduration();return this;} | ||
710 | public const int SubdurationFieldTag=3; | ||
711 | public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} } | ||
712 | public PBJ.Duration Subduration{ get { | ||
713 | if (HasSubduration) { | ||
714 | return PBJ._PBJ.CastDuration(super.Subduration); | ||
715 | } else { | ||
716 | return PBJ._PBJ.CastDuration(); | ||
717 | } | ||
718 | } | ||
719 | set { | ||
720 | super.Subduration=(PBJ._PBJ.Construct(value)); | ||
721 | } | ||
722 | } | ||
723 | public Builder ClearSubnormal() { super.ClearSubnormal();return this;} | ||
724 | public const int SubnormalFieldTag=4; | ||
725 | public bool HasSubnormal{ get {return super.SubnormalCount>=2;} } | ||
726 | public PBJ.Vector3f Subnormal{ get { | ||
727 | int index=0; | ||
728 | if (HasSubnormal) { | ||
729 | return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1)); | ||
730 | } else { | ||
731 | return PBJ._PBJ.CastNormal(); | ||
732 | } | ||
733 | } | ||
734 | set { | ||
735 | super.ClearSubnormal(); | ||
736 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
737 | super.AddSubnormal(_PBJtempArray[0]); | ||
738 | super.AddSubnormal(_PBJtempArray[1]); | ||
739 | } | ||
740 | } | ||
741 | } | ||
742 | } | ||
743 | } | ||
744 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
745 | return false; | ||
746 | } | ||
747 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
748 | return false||(field_tag>=100&&field_tag<=199); | ||
749 | } | ||
750 | public const int XxdFieldTag=20; | ||
751 | public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} } | ||
752 | public double Xxd{ get { | ||
753 | if (HasXxd) { | ||
754 | return PBJ._PBJ.CastDouble(super.Xxd); | ||
755 | } else { | ||
756 | return 10.3; | ||
757 | } | ||
758 | } | ||
759 | } | ||
760 | public const int XxfFieldTag=21; | ||
761 | public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} } | ||
762 | public float Xxf{ get { | ||
763 | if (HasXxf) { | ||
764 | return PBJ._PBJ.CastFloat(super.Xxf); | ||
765 | } else { | ||
766 | return PBJ._PBJ.CastFloat(); | ||
767 | } | ||
768 | } | ||
769 | } | ||
770 | public const int Xxu32FieldTag=22; | ||
771 | public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} } | ||
772 | public uint Xxu32{ get { | ||
773 | if (HasXxu32) { | ||
774 | return PBJ._PBJ.CastUint32(super.Xxu32); | ||
775 | } else { | ||
776 | return PBJ._PBJ.CastUint32(); | ||
777 | } | ||
778 | } | ||
779 | } | ||
780 | public const int XxsFieldTag=23; | ||
781 | public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} } | ||
782 | public string Xxs{ get { | ||
783 | if (HasXxs) { | ||
784 | return PBJ._PBJ.CastString(super.Xxs); | ||
785 | } else { | ||
786 | return PBJ._PBJ.CastString(); | ||
787 | } | ||
788 | } | ||
789 | } | ||
790 | public const int XxbFieldTag=24; | ||
791 | public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} } | ||
792 | public pb::ByteString Xxb{ get { | ||
793 | if (HasXxb) { | ||
794 | return PBJ._PBJ.CastBytes(super.Xxb); | ||
795 | } else { | ||
796 | return PBJ._PBJ.CastBytes(); | ||
797 | } | ||
798 | } | ||
799 | } | ||
800 | public const int XxssFieldTag=25; | ||
801 | public int XxssCount { get { return super.XxssCount;} } | ||
802 | public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));} | ||
803 | public string Xxss(int index) { | ||
804 | return (string)PBJ._PBJ.CastString(super.GetXxss(index)); | ||
805 | } | ||
806 | public const int XxbbFieldTag=26; | ||
807 | public int XxbbCount { get { return super.XxbbCount;} } | ||
808 | public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));} | ||
809 | public pb::ByteString Xxbb(int index) { | ||
810 | return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index)); | ||
811 | } | ||
812 | public const int XxffFieldTag=27; | ||
813 | public int XxffCount { get { return super.XxffCount;} } | ||
814 | public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));} | ||
815 | public float Xxff(int index) { | ||
816 | return (float)PBJ._PBJ.CastFloat(super.GetXxff(index)); | ||
817 | } | ||
818 | public const int XxnnFieldTag=29; | ||
819 | public int XxnnCount { get { return super.XxnnCount/2;} } | ||
820 | public bool HasXxnn(int index) { return true; } | ||
821 | public PBJ.Vector3f GetXxnn(int index) { | ||
822 | if (HasXxnn(index)) { | ||
823 | return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1)); | ||
824 | } else { | ||
825 | return PBJ._PBJ.CastNormal(); | ||
826 | } | ||
827 | } | ||
828 | public const int XxfrFieldTag=28; | ||
829 | public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} } | ||
830 | public float Xxfr{ get { | ||
831 | if (HasXxfr) { | ||
832 | return PBJ._PBJ.CastFloat(super.Xxfr); | ||
833 | } else { | ||
834 | return PBJ._PBJ.CastFloat(); | ||
835 | } | ||
836 | } | ||
837 | } | ||
838 | public const int NFieldTag=1; | ||
839 | public bool HasN{ get {return super.NCount>=2;} } | ||
840 | public PBJ.Vector3f N{ get { | ||
841 | int index=0; | ||
842 | if (HasN) { | ||
843 | return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1)); | ||
844 | } else { | ||
845 | return PBJ._PBJ.CastNormal(); | ||
846 | } | ||
847 | } | ||
848 | } | ||
849 | public const int V2FFieldTag=2; | ||
850 | public bool HasV2F{ get {return super.V2FCount>=2;} } | ||
851 | public PBJ.Vector2f V2F{ get { | ||
852 | int index=0; | ||
853 | if (HasV2F) { | ||
854 | return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); | ||
855 | } else { | ||
856 | return PBJ._PBJ.CastVector2f(); | ||
857 | } | ||
858 | } | ||
859 | } | ||
860 | public const int V2DFieldTag=3; | ||
861 | public bool HasV2D{ get {return super.V2DCount>=2;} } | ||
862 | public PBJ.Vector2d V2D{ get { | ||
863 | int index=0; | ||
864 | if (HasV2D) { | ||
865 | return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1)); | ||
866 | } else { | ||
867 | return PBJ._PBJ.CastVector2d(); | ||
868 | } | ||
869 | } | ||
870 | } | ||
871 | public const int V3FFieldTag=4; | ||
872 | public bool HasV3F{ get {return super.V3FCount>=3;} } | ||
873 | public PBJ.Vector3f V3F{ get { | ||
874 | int index=0; | ||
875 | if (HasV3F) { | ||
876 | return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); | ||
877 | } else { | ||
878 | return PBJ._PBJ.CastVector3f(); | ||
879 | } | ||
880 | } | ||
881 | } | ||
882 | public const int V3DFieldTag=5; | ||
883 | public bool HasV3D{ get {return super.V3DCount>=3;} } | ||
884 | public PBJ.Vector3d V3D{ get { | ||
885 | int index=0; | ||
886 | if (HasV3D) { | ||
887 | return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2)); | ||
888 | } else { | ||
889 | return PBJ._PBJ.CastVector3d(); | ||
890 | } | ||
891 | } | ||
892 | } | ||
893 | public const int V4FFieldTag=6; | ||
894 | public bool HasV4F{ get {return super.V4FCount>=4;} } | ||
895 | public PBJ.Vector4f V4F{ get { | ||
896 | int index=0; | ||
897 | if (HasV4F) { | ||
898 | return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3)); | ||
899 | } else { | ||
900 | return PBJ._PBJ.CastVector4f(); | ||
901 | } | ||
902 | } | ||
903 | } | ||
904 | public const int V4DFieldTag=7; | ||
905 | public bool HasV4D{ get {return super.V4DCount>=4;} } | ||
906 | public PBJ.Vector4d V4D{ get { | ||
907 | int index=0; | ||
908 | if (HasV4D) { | ||
909 | return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3)); | ||
910 | } else { | ||
911 | return PBJ._PBJ.CastVector4d(); | ||
912 | } | ||
913 | } | ||
914 | } | ||
915 | public const int QFieldTag=8; | ||
916 | public bool HasQ{ get {return super.QCount>=3;} } | ||
917 | public PBJ.Quaternion Q{ get { | ||
918 | int index=0; | ||
919 | if (HasQ) { | ||
920 | return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2)); | ||
921 | } else { | ||
922 | return PBJ._PBJ.CastQuaternion(); | ||
923 | } | ||
924 | } | ||
925 | } | ||
926 | public const int UFieldTag=9; | ||
927 | public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} } | ||
928 | public PBJ.UUID U{ get { | ||
929 | if (HasU) { | ||
930 | return PBJ._PBJ.CastUuid(super.U); | ||
931 | } else { | ||
932 | return PBJ._PBJ.CastUuid(); | ||
933 | } | ||
934 | } | ||
935 | } | ||
936 | public const int AFieldTag=10; | ||
937 | public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} } | ||
938 | public float A{ get { | ||
939 | if (HasA) { | ||
940 | return PBJ._PBJ.CastAngle(super.A); | ||
941 | } else { | ||
942 | return PBJ._PBJ.CastAngle(); | ||
943 | } | ||
944 | } | ||
945 | } | ||
946 | public const int TFieldTag=11; | ||
947 | public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} } | ||
948 | public PBJ.Time T{ get { | ||
949 | if (HasT) { | ||
950 | return PBJ._PBJ.CastTime(super.T); | ||
951 | } else { | ||
952 | return PBJ._PBJ.CastTime(); | ||
953 | } | ||
954 | } | ||
955 | } | ||
956 | public const int DFieldTag=12; | ||
957 | public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} } | ||
958 | public PBJ.Duration D{ get { | ||
959 | if (HasD) { | ||
960 | return PBJ._PBJ.CastDuration(super.D); | ||
961 | } else { | ||
962 | return PBJ._PBJ.CastDuration(); | ||
963 | } | ||
964 | } | ||
965 | } | ||
966 | public const int F32FieldTag=13; | ||
967 | public bool HasF32 { get { | ||
968 | if (!super.HasF32) return false; | ||
969 | return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); | ||
970 | } } | ||
971 | public uint F32{ get { | ||
972 | if (HasF32) { | ||
973 | return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); | ||
974 | } else { | ||
975 | return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); | ||
976 | } | ||
977 | } | ||
978 | } | ||
979 | public const int F64FieldTag=14; | ||
980 | public bool HasF64 { get { | ||
981 | if (!super.HasF64) return false; | ||
982 | return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); | ||
983 | } } | ||
984 | public ulong F64{ get { | ||
985 | if (HasF64) { | ||
986 | return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); | ||
987 | } else { | ||
988 | return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); | ||
989 | } | ||
990 | } | ||
991 | } | ||
992 | public const int BsfFieldTag=15; | ||
993 | public bool HasBsf{ get {return super.BsfCount>=4;} } | ||
994 | public PBJ.BoundingSphere3f Bsf{ get { | ||
995 | int index=0; | ||
996 | if (HasBsf) { | ||
997 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3)); | ||
998 | } else { | ||
999 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
1000 | } | ||
1001 | } | ||
1002 | } | ||
1003 | public const int BsdFieldTag=16; | ||
1004 | public bool HasBsd{ get {return super.BsdCount>=4;} } | ||
1005 | public PBJ.BoundingSphere3d Bsd{ get { | ||
1006 | int index=0; | ||
1007 | if (HasBsd) { | ||
1008 | return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3)); | ||
1009 | } else { | ||
1010 | return PBJ._PBJ.CastBoundingsphere3d(); | ||
1011 | } | ||
1012 | } | ||
1013 | } | ||
1014 | public const int BbfFieldTag=17; | ||
1015 | public bool HasBbf{ get {return super.BbfCount>=6;} } | ||
1016 | public PBJ.BoundingBox3f3f Bbf{ get { | ||
1017 | int index=0; | ||
1018 | if (HasBbf) { | ||
1019 | return PBJ._PBJ.CastBoundingbox3f3f(super.GetBbf(index*6+0),super.GetBbf(index*6+1),super.GetBbf(index*6+2),super.GetBbf(index*6+3),super.GetBbf(index*6+4),super.GetBbf(index*6+5)); | ||
1020 | } else { | ||
1021 | return PBJ._PBJ.CastBoundingbox3f3f(); | ||
1022 | } | ||
1023 | } | ||
1024 | } | ||
1025 | public const int BbdFieldTag=18; | ||
1026 | public bool HasBbd{ get {return super.BbdCount>=6;} } | ||
1027 | public PBJ.BoundingBox3d3f Bbd{ get { | ||
1028 | int index=0; | ||
1029 | if (HasBbd) { | ||
1030 | return PBJ._PBJ.CastBoundingbox3d3f(super.GetBbd(index*6+0),super.GetBbd(index*6+1),super.GetBbd(index*6+2),super.GetBbd(index*6+3),super.GetBbd(index*6+4),super.GetBbd(index*6+5)); | ||
1031 | } else { | ||
1032 | return PBJ._PBJ.CastBoundingbox3d3f(); | ||
1033 | } | ||
1034 | } | ||
1035 | } | ||
1036 | public const int E32FieldTag=19; | ||
1037 | public bool HasE32{ get {return super.HasE32;} } | ||
1038 | public Types.Enum32 E32{ get { | ||
1039 | if (HasE32) { | ||
1040 | return (Types.Enum32)super.E32; | ||
1041 | } else { | ||
1042 | return new Types.Enum32(); | ||
1043 | } | ||
1044 | } | ||
1045 | } | ||
1046 | public const int SubmesFieldTag=30; | ||
1047 | public bool HasSubmes{ get {return super.HasSubmes;} } | ||
1048 | public Types.SubMessage Submes{ get { | ||
1049 | if (HasSubmes) { | ||
1050 | return new Types.SubMessage(super.Submes); | ||
1051 | } else { | ||
1052 | return new Types.SubMessage(); | ||
1053 | } | ||
1054 | } | ||
1055 | } | ||
1056 | public const int SubmessersFieldTag=31; | ||
1057 | public int SubmessersCount { get { return super.SubmessersCount;} } | ||
1058 | public bool HasSubmessers(int index) {return true;} | ||
1059 | public Types.SubMessage Submessers(int index) { | ||
1060 | return new Types.SubMessage(super.GetSubmessers(index)); | ||
1061 | } | ||
1062 | public const int ShaFieldTag=32; | ||
1063 | public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } | ||
1064 | public PBJ.SHA256 Sha{ get { | ||
1065 | if (HasSha) { | ||
1066 | return PBJ._PBJ.CastSha256(super.Sha); | ||
1067 | } else { | ||
1068 | return PBJ._PBJ.CastSha256(); | ||
1069 | } | ||
1070 | } | ||
1071 | } | ||
1072 | public const int ShasFieldTag=33; | ||
1073 | public int ShasCount { get { return super.ShasCount;} } | ||
1074 | public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} | ||
1075 | public PBJ.SHA256 Shas(int index) { | ||
1076 | return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); | ||
1077 | } | ||
1078 | public const int ExtmesFieldTag=34; | ||
1079 | public bool HasExtmes{ get {return super.HasExtmes;} } | ||
1080 | public ExternalMessage Extmes{ get { | ||
1081 | if (HasExtmes) { | ||
1082 | return new ExternalMessage(super.Extmes); | ||
1083 | } else { | ||
1084 | return new ExternalMessage(); | ||
1085 | } | ||
1086 | } | ||
1087 | } | ||
1088 | public const int ExtmessersFieldTag=35; | ||
1089 | public int ExtmessersCount { get { return super.ExtmessersCount;} } | ||
1090 | public bool HasExtmessers(int index) {return true;} | ||
1091 | public ExternalMessage Extmessers(int index) { | ||
1092 | return new ExternalMessage(super.GetExtmessers(index)); | ||
1093 | } | ||
1094 | public const int ExtmesserFieldTag=36; | ||
1095 | public bool HasExtmesser{ get {return super.HasExtmesser;} } | ||
1096 | public ExternalMessage Extmesser{ get { | ||
1097 | if (HasExtmesser) { | ||
1098 | return new ExternalMessage(super.Extmesser); | ||
1099 | } else { | ||
1100 | return new ExternalMessage(); | ||
1101 | } | ||
1102 | } | ||
1103 | } | ||
1104 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
1105 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
1106 | public static Builder CreateBuilder() { return new Builder(); } | ||
1107 | public static Builder CreateBuilder(TestMessage prototype) { | ||
1108 | return (Builder)new Builder().MergeFrom(prototype); | ||
1109 | } | ||
1110 | public static TestMessage ParseFrom(pb::ByteString data) { | ||
1111 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); | ||
1112 | } | ||
1113 | public static TestMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
1114 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); | ||
1115 | } | ||
1116 | public static TestMessage ParseFrom(byte[] data) { | ||
1117 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); | ||
1118 | } | ||
1119 | public static TestMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
1120 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); | ||
1121 | } | ||
1122 | public static TestMessage ParseFrom(global::System.IO.Stream data) { | ||
1123 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); | ||
1124 | } | ||
1125 | public static TestMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
1126 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); | ||
1127 | } | ||
1128 | public static TestMessage ParseFrom(pb::CodedInputStream data) { | ||
1129 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data)); | ||
1130 | } | ||
1131 | public static TestMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
1132 | return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er)); | ||
1133 | } | ||
1134 | protected override bool _HasAllPBJFields{ get { | ||
1135 | return true | ||
1136 | &&HasV3F | ||
1137 | ; | ||
1138 | } } | ||
1139 | public bool IsInitialized { get { | ||
1140 | return super.IsInitialized&&_HasAllPBJFields; | ||
1141 | } } | ||
1142 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
1143 | protected override bool _HasAllPBJFields{ get { | ||
1144 | return true | ||
1145 | &&HasV3F | ||
1146 | ; | ||
1147 | } } | ||
1148 | public bool IsInitialized { get { | ||
1149 | return super.IsInitialized&&_HasAllPBJFields; | ||
1150 | } } | ||
1151 | protected _PBJ_Internal.TestMessage.Builder super; | ||
1152 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
1153 | public _PBJ_Internal.TestMessage.Builder _PBJSuper{ get { return super;} } | ||
1154 | public Builder() {super = new _PBJ_Internal.TestMessage.Builder();} | ||
1155 | public Builder(_PBJ_Internal.TestMessage.Builder other) { | ||
1156 | super=other; | ||
1157 | } | ||
1158 | public Builder Clone() {return new Builder(super.Clone());} | ||
1159 | public Builder MergeFrom(TestMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
1160 | public Builder Clear() {super.Clear();return this;} | ||
1161 | public TestMessage BuildPartial() {return new TestMessage(super.BuildPartial());} | ||
1162 | public TestMessage Build() {if (_HasAllPBJFields) return new TestMessage(super.Build());return null;} | ||
1163 | public pbd::MessageDescriptor DescriptorForType { | ||
1164 | get { return TestMessage.Descriptor; } } | ||
1165 | public Builder ClearXxd() { super.ClearXxd();return this;} | ||
1166 | public const int XxdFieldTag=20; | ||
1167 | public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} } | ||
1168 | public double Xxd{ get { | ||
1169 | if (HasXxd) { | ||
1170 | return PBJ._PBJ.CastDouble(super.Xxd); | ||
1171 | } else { | ||
1172 | return 10.3; | ||
1173 | } | ||
1174 | } | ||
1175 | set { | ||
1176 | super.Xxd=(PBJ._PBJ.Construct(value)); | ||
1177 | } | ||
1178 | } | ||
1179 | public Builder ClearXxf() { super.ClearXxf();return this;} | ||
1180 | public const int XxfFieldTag=21; | ||
1181 | public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} } | ||
1182 | public float Xxf{ get { | ||
1183 | if (HasXxf) { | ||
1184 | return PBJ._PBJ.CastFloat(super.Xxf); | ||
1185 | } else { | ||
1186 | return PBJ._PBJ.CastFloat(); | ||
1187 | } | ||
1188 | } | ||
1189 | set { | ||
1190 | super.Xxf=(PBJ._PBJ.Construct(value)); | ||
1191 | } | ||
1192 | } | ||
1193 | public Builder ClearXxu32() { super.ClearXxu32();return this;} | ||
1194 | public const int Xxu32FieldTag=22; | ||
1195 | public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} } | ||
1196 | public uint Xxu32{ get { | ||
1197 | if (HasXxu32) { | ||
1198 | return PBJ._PBJ.CastUint32(super.Xxu32); | ||
1199 | } else { | ||
1200 | return PBJ._PBJ.CastUint32(); | ||
1201 | } | ||
1202 | } | ||
1203 | set { | ||
1204 | super.Xxu32=(PBJ._PBJ.Construct(value)); | ||
1205 | } | ||
1206 | } | ||
1207 | public Builder ClearXxs() { super.ClearXxs();return this;} | ||
1208 | public const int XxsFieldTag=23; | ||
1209 | public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} } | ||
1210 | public string Xxs{ get { | ||
1211 | if (HasXxs) { | ||
1212 | return PBJ._PBJ.CastString(super.Xxs); | ||
1213 | } else { | ||
1214 | return PBJ._PBJ.CastString(); | ||
1215 | } | ||
1216 | } | ||
1217 | set { | ||
1218 | super.Xxs=(PBJ._PBJ.Construct(value)); | ||
1219 | } | ||
1220 | } | ||
1221 | public Builder ClearXxb() { super.ClearXxb();return this;} | ||
1222 | public const int XxbFieldTag=24; | ||
1223 | public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} } | ||
1224 | public pb::ByteString Xxb{ get { | ||
1225 | if (HasXxb) { | ||
1226 | return PBJ._PBJ.CastBytes(super.Xxb); | ||
1227 | } else { | ||
1228 | return PBJ._PBJ.CastBytes(); | ||
1229 | } | ||
1230 | } | ||
1231 | set { | ||
1232 | super.Xxb=(PBJ._PBJ.Construct(value)); | ||
1233 | } | ||
1234 | } | ||
1235 | public Builder ClearXxss() { super.ClearXxss();return this;} | ||
1236 | public Builder SetXxss(int index, string value) { | ||
1237 | super.SetXxss(index,PBJ._PBJ.Construct(value)); | ||
1238 | return this; | ||
1239 | } | ||
1240 | public const int XxssFieldTag=25; | ||
1241 | public int XxssCount { get { return super.XxssCount;} } | ||
1242 | public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));} | ||
1243 | public string Xxss(int index) { | ||
1244 | return (string)PBJ._PBJ.CastString(super.GetXxss(index)); | ||
1245 | } | ||
1246 | public Builder AddXxss(string value) { | ||
1247 | super.AddXxss(PBJ._PBJ.Construct(value)); | ||
1248 | return this; | ||
1249 | } | ||
1250 | public Builder ClearXxbb() { super.ClearXxbb();return this;} | ||
1251 | public Builder SetXxbb(int index, pb::ByteString value) { | ||
1252 | super.SetXxbb(index,PBJ._PBJ.Construct(value)); | ||
1253 | return this; | ||
1254 | } | ||
1255 | public const int XxbbFieldTag=26; | ||
1256 | public int XxbbCount { get { return super.XxbbCount;} } | ||
1257 | public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));} | ||
1258 | public pb::ByteString Xxbb(int index) { | ||
1259 | return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index)); | ||
1260 | } | ||
1261 | public Builder AddXxbb(pb::ByteString value) { | ||
1262 | super.AddXxbb(PBJ._PBJ.Construct(value)); | ||
1263 | return this; | ||
1264 | } | ||
1265 | public Builder ClearXxff() { super.ClearXxff();return this;} | ||
1266 | public Builder SetXxff(int index, float value) { | ||
1267 | super.SetXxff(index,PBJ._PBJ.Construct(value)); | ||
1268 | return this; | ||
1269 | } | ||
1270 | public const int XxffFieldTag=27; | ||
1271 | public int XxffCount { get { return super.XxffCount;} } | ||
1272 | public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));} | ||
1273 | public float Xxff(int index) { | ||
1274 | return (float)PBJ._PBJ.CastFloat(super.GetXxff(index)); | ||
1275 | } | ||
1276 | public Builder AddXxff(float value) { | ||
1277 | super.AddXxff(PBJ._PBJ.Construct(value)); | ||
1278 | return this; | ||
1279 | } | ||
1280 | public Builder ClearXxnn() { super.ClearXxnn();return this;} | ||
1281 | public const int XxnnFieldTag=29; | ||
1282 | public int XxnnCount { get { return super.XxnnCount/2;} } | ||
1283 | public bool HasXxnn(int index) { return true; } | ||
1284 | public PBJ.Vector3f GetXxnn(int index) { | ||
1285 | if (HasXxnn(index)) { | ||
1286 | return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1)); | ||
1287 | } else { | ||
1288 | return PBJ._PBJ.CastNormal(); | ||
1289 | } | ||
1290 | } | ||
1291 | public Builder AddXxnn(PBJ.Vector3f value) { | ||
1292 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
1293 | super.AddXxnn(_PBJtempArray[0]); | ||
1294 | super.AddXxnn(_PBJtempArray[1]); | ||
1295 | return this; | ||
1296 | } | ||
1297 | public Builder SetXxnn(int index,PBJ.Vector3f value) { | ||
1298 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
1299 | super.SetXxnn(index*2+0,_PBJtempArray[0]); | ||
1300 | super.SetXxnn(index*2+1,_PBJtempArray[1]); | ||
1301 | return this; | ||
1302 | } | ||
1303 | public Builder ClearXxfr() { super.ClearXxfr();return this;} | ||
1304 | public const int XxfrFieldTag=28; | ||
1305 | public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} } | ||
1306 | public float Xxfr{ get { | ||
1307 | if (HasXxfr) { | ||
1308 | return PBJ._PBJ.CastFloat(super.Xxfr); | ||
1309 | } else { | ||
1310 | return PBJ._PBJ.CastFloat(); | ||
1311 | } | ||
1312 | } | ||
1313 | set { | ||
1314 | super.Xxfr=(PBJ._PBJ.Construct(value)); | ||
1315 | } | ||
1316 | } | ||
1317 | public Builder ClearN() { super.ClearN();return this;} | ||
1318 | public const int NFieldTag=1; | ||
1319 | public bool HasN{ get {return super.NCount>=2;} } | ||
1320 | public PBJ.Vector3f N{ get { | ||
1321 | int index=0; | ||
1322 | if (HasN) { | ||
1323 | return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1)); | ||
1324 | } else { | ||
1325 | return PBJ._PBJ.CastNormal(); | ||
1326 | } | ||
1327 | } | ||
1328 | set { | ||
1329 | super.ClearN(); | ||
1330 | float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value); | ||
1331 | super.AddN(_PBJtempArray[0]); | ||
1332 | super.AddN(_PBJtempArray[1]); | ||
1333 | } | ||
1334 | } | ||
1335 | public Builder ClearV2F() { super.ClearV2F();return this;} | ||
1336 | public const int V2FFieldTag=2; | ||
1337 | public bool HasV2F{ get {return super.V2FCount>=2;} } | ||
1338 | public PBJ.Vector2f V2F{ get { | ||
1339 | int index=0; | ||
1340 | if (HasV2F) { | ||
1341 | return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1)); | ||
1342 | } else { | ||
1343 | return PBJ._PBJ.CastVector2f(); | ||
1344 | } | ||
1345 | } | ||
1346 | set { | ||
1347 | super.ClearV2F(); | ||
1348 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value); | ||
1349 | super.AddV2F(_PBJtempArray[0]); | ||
1350 | super.AddV2F(_PBJtempArray[1]); | ||
1351 | } | ||
1352 | } | ||
1353 | public Builder ClearV2D() { super.ClearV2D();return this;} | ||
1354 | public const int V2DFieldTag=3; | ||
1355 | public bool HasV2D{ get {return super.V2DCount>=2;} } | ||
1356 | public PBJ.Vector2d V2D{ get { | ||
1357 | int index=0; | ||
1358 | if (HasV2D) { | ||
1359 | return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1)); | ||
1360 | } else { | ||
1361 | return PBJ._PBJ.CastVector2d(); | ||
1362 | } | ||
1363 | } | ||
1364 | set { | ||
1365 | super.ClearV2D(); | ||
1366 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector2d(value); | ||
1367 | super.AddV2D(_PBJtempArray[0]); | ||
1368 | super.AddV2D(_PBJtempArray[1]); | ||
1369 | } | ||
1370 | } | ||
1371 | public Builder ClearV3F() { super.ClearV3F();return this;} | ||
1372 | public const int V3FFieldTag=4; | ||
1373 | public bool HasV3F{ get {return super.V3FCount>=3;} } | ||
1374 | public PBJ.Vector3f V3F{ get { | ||
1375 | int index=0; | ||
1376 | if (HasV3F) { | ||
1377 | return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2)); | ||
1378 | } else { | ||
1379 | return PBJ._PBJ.CastVector3f(); | ||
1380 | } | ||
1381 | } | ||
1382 | set { | ||
1383 | super.ClearV3F(); | ||
1384 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value); | ||
1385 | super.AddV3F(_PBJtempArray[0]); | ||
1386 | super.AddV3F(_PBJtempArray[1]); | ||
1387 | super.AddV3F(_PBJtempArray[2]); | ||
1388 | } | ||
1389 | } | ||
1390 | public Builder ClearV3D() { super.ClearV3D();return this;} | ||
1391 | public const int V3DFieldTag=5; | ||
1392 | public bool HasV3D{ get {return super.V3DCount>=3;} } | ||
1393 | public PBJ.Vector3d V3D{ get { | ||
1394 | int index=0; | ||
1395 | if (HasV3D) { | ||
1396 | return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2)); | ||
1397 | } else { | ||
1398 | return PBJ._PBJ.CastVector3d(); | ||
1399 | } | ||
1400 | } | ||
1401 | set { | ||
1402 | super.ClearV3D(); | ||
1403 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value); | ||
1404 | super.AddV3D(_PBJtempArray[0]); | ||
1405 | super.AddV3D(_PBJtempArray[1]); | ||
1406 | super.AddV3D(_PBJtempArray[2]); | ||
1407 | } | ||
1408 | } | ||
1409 | public Builder ClearV4F() { super.ClearV4F();return this;} | ||
1410 | public const int V4FFieldTag=6; | ||
1411 | public bool HasV4F{ get {return super.V4FCount>=4;} } | ||
1412 | public PBJ.Vector4f V4F{ get { | ||
1413 | int index=0; | ||
1414 | if (HasV4F) { | ||
1415 | return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3)); | ||
1416 | } else { | ||
1417 | return PBJ._PBJ.CastVector4f(); | ||
1418 | } | ||
1419 | } | ||
1420 | set { | ||
1421 | super.ClearV4F(); | ||
1422 | float[] _PBJtempArray=PBJ._PBJ.ConstructVector4f(value); | ||
1423 | super.AddV4F(_PBJtempArray[0]); | ||
1424 | super.AddV4F(_PBJtempArray[1]); | ||
1425 | super.AddV4F(_PBJtempArray[2]); | ||
1426 | super.AddV4F(_PBJtempArray[3]); | ||
1427 | } | ||
1428 | } | ||
1429 | public Builder ClearV4D() { super.ClearV4D();return this;} | ||
1430 | public const int V4DFieldTag=7; | ||
1431 | public bool HasV4D{ get {return super.V4DCount>=4;} } | ||
1432 | public PBJ.Vector4d V4D{ get { | ||
1433 | int index=0; | ||
1434 | if (HasV4D) { | ||
1435 | return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3)); | ||
1436 | } else { | ||
1437 | return PBJ._PBJ.CastVector4d(); | ||
1438 | } | ||
1439 | } | ||
1440 | set { | ||
1441 | super.ClearV4D(); | ||
1442 | double[] _PBJtempArray=PBJ._PBJ.ConstructVector4d(value); | ||
1443 | super.AddV4D(_PBJtempArray[0]); | ||
1444 | super.AddV4D(_PBJtempArray[1]); | ||
1445 | super.AddV4D(_PBJtempArray[2]); | ||
1446 | super.AddV4D(_PBJtempArray[3]); | ||
1447 | } | ||
1448 | } | ||
1449 | public Builder ClearQ() { super.ClearQ();return this;} | ||
1450 | public const int QFieldTag=8; | ||
1451 | public bool HasQ{ get {return super.QCount>=3;} } | ||
1452 | public PBJ.Quaternion Q{ get { | ||
1453 | int index=0; | ||
1454 | if (HasQ) { | ||
1455 | return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2)); | ||
1456 | } else { | ||
1457 | return PBJ._PBJ.CastQuaternion(); | ||
1458 | } | ||
1459 | } | ||
1460 | set { | ||
1461 | super.ClearQ(); | ||
1462 | float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value); | ||
1463 | super.AddQ(_PBJtempArray[0]); | ||
1464 | super.AddQ(_PBJtempArray[1]); | ||
1465 | super.AddQ(_PBJtempArray[2]); | ||
1466 | } | ||
1467 | } | ||
1468 | public Builder ClearU() { super.ClearU();return this;} | ||
1469 | public const int UFieldTag=9; | ||
1470 | public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} } | ||
1471 | public PBJ.UUID U{ get { | ||
1472 | if (HasU) { | ||
1473 | return PBJ._PBJ.CastUuid(super.U); | ||
1474 | } else { | ||
1475 | return PBJ._PBJ.CastUuid(); | ||
1476 | } | ||
1477 | } | ||
1478 | set { | ||
1479 | super.U=(PBJ._PBJ.Construct(value)); | ||
1480 | } | ||
1481 | } | ||
1482 | public Builder ClearA() { super.ClearA();return this;} | ||
1483 | public const int AFieldTag=10; | ||
1484 | public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} } | ||
1485 | public float A{ get { | ||
1486 | if (HasA) { | ||
1487 | return PBJ._PBJ.CastAngle(super.A); | ||
1488 | } else { | ||
1489 | return PBJ._PBJ.CastAngle(); | ||
1490 | } | ||
1491 | } | ||
1492 | set { | ||
1493 | super.A=(PBJ._PBJ.Construct(value)); | ||
1494 | } | ||
1495 | } | ||
1496 | public Builder ClearT() { super.ClearT();return this;} | ||
1497 | public const int TFieldTag=11; | ||
1498 | public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} } | ||
1499 | public PBJ.Time T{ get { | ||
1500 | if (HasT) { | ||
1501 | return PBJ._PBJ.CastTime(super.T); | ||
1502 | } else { | ||
1503 | return PBJ._PBJ.CastTime(); | ||
1504 | } | ||
1505 | } | ||
1506 | set { | ||
1507 | super.T=(PBJ._PBJ.Construct(value)); | ||
1508 | } | ||
1509 | } | ||
1510 | public Builder ClearD() { super.ClearD();return this;} | ||
1511 | public const int DFieldTag=12; | ||
1512 | public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} } | ||
1513 | public PBJ.Duration D{ get { | ||
1514 | if (HasD) { | ||
1515 | return PBJ._PBJ.CastDuration(super.D); | ||
1516 | } else { | ||
1517 | return PBJ._PBJ.CastDuration(); | ||
1518 | } | ||
1519 | } | ||
1520 | set { | ||
1521 | super.D=(PBJ._PBJ.Construct(value)); | ||
1522 | } | ||
1523 | } | ||
1524 | public Builder ClearF32() { super.ClearF32();return this;} | ||
1525 | public const int F32FieldTag=13; | ||
1526 | public bool HasF32 { get { | ||
1527 | if (!super.HasF32) return false; | ||
1528 | return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); | ||
1529 | } } | ||
1530 | public uint F32{ get { | ||
1531 | if (HasF32) { | ||
1532 | return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); | ||
1533 | } else { | ||
1534 | return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA); | ||
1535 | } | ||
1536 | } | ||
1537 | set { | ||
1538 | super.F32=((value)); | ||
1539 | } | ||
1540 | } | ||
1541 | public Builder ClearF64() { super.ClearF64();return this;} | ||
1542 | public const int F64FieldTag=14; | ||
1543 | public bool HasF64 { get { | ||
1544 | if (!super.HasF64) return false; | ||
1545 | return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); | ||
1546 | } } | ||
1547 | public ulong F64{ get { | ||
1548 | if (HasF64) { | ||
1549 | return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); | ||
1550 | } else { | ||
1551 | return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL); | ||
1552 | } | ||
1553 | } | ||
1554 | set { | ||
1555 | super.F64=((value)); | ||
1556 | } | ||
1557 | } | ||
1558 | public Builder ClearBsf() { super.ClearBsf();return this;} | ||
1559 | public const int BsfFieldTag=15; | ||
1560 | public bool HasBsf{ get {return super.BsfCount>=4;} } | ||
1561 | public PBJ.BoundingSphere3f Bsf{ get { | ||
1562 | int index=0; | ||
1563 | if (HasBsf) { | ||
1564 | return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3)); | ||
1565 | } else { | ||
1566 | return PBJ._PBJ.CastBoundingsphere3f(); | ||
1567 | } | ||
1568 | } | ||
1569 | set { | ||
1570 | super.ClearBsf(); | ||
1571 | float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value); | ||
1572 | super.AddBsf(_PBJtempArray[0]); | ||
1573 | super.AddBsf(_PBJtempArray[1]); | ||
1574 | super.AddBsf(_PBJtempArray[2]); | ||
1575 | super.AddBsf(_PBJtempArray[3]); | ||
1576 | } | ||
1577 | } | ||
1578 | public Builder ClearBsd() { super.ClearBsd();return this;} | ||
1579 | public const int BsdFieldTag=16; | ||
1580 | public bool HasBsd{ get {return super.BsdCount>=4;} } | ||
1581 | public PBJ.BoundingSphere3d Bsd{ get { | ||
1582 | int index=0; | ||
1583 | if (HasBsd) { | ||
1584 | return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3)); | ||
1585 | } else { | ||
1586 | return PBJ._PBJ.CastBoundingsphere3d(); | ||
1587 | } | ||
1588 | } | ||
1589 | set { | ||
1590 | super.ClearBsd(); | ||
1591 | double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3d(value); | ||
1592 | super.AddBsd(_PBJtempArray[0]); | ||
1593 | super.AddBsd(_PBJtempArray[1]); | ||
1594 | super.AddBsd(_PBJtempArray[2]); | ||
1595 | super.AddBsd(_PBJtempArray[3]); | ||
1596 | } | ||
1597 | } | ||
1598 | public Builder ClearBbf() { super.ClearBbf();return this;} | ||
1599 | public const int BbfFieldTag=17; | ||
1600 | public bool HasBbf{ get {return super.BbfCount>=6;} } | ||
1601 | public PBJ.BoundingBox3f3f Bbf{ get { | ||
1602 | int index=0; | ||
1603 | if (HasBbf) { | ||
1604 | return PBJ._PBJ.CastBoundingbox3f3f(super.GetBbf(index*6+0),super.GetBbf(index*6+1),super.GetBbf(index*6+2),super.GetBbf(index*6+3),super.GetBbf(index*6+4),super.GetBbf(index*6+5)); | ||
1605 | } else { | ||
1606 | return PBJ._PBJ.CastBoundingbox3f3f(); | ||
1607 | } | ||
1608 | } | ||
1609 | set { | ||
1610 | super.ClearBbf(); | ||
1611 | float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3f3f(value); | ||
1612 | super.AddBbf(_PBJtempArray[0]); | ||
1613 | super.AddBbf(_PBJtempArray[1]); | ||
1614 | super.AddBbf(_PBJtempArray[2]); | ||
1615 | super.AddBbf(_PBJtempArray[3]); | ||
1616 | super.AddBbf(_PBJtempArray[4]); | ||
1617 | super.AddBbf(_PBJtempArray[5]); | ||
1618 | } | ||
1619 | } | ||
1620 | public Builder ClearBbd() { super.ClearBbd();return this;} | ||
1621 | public const int BbdFieldTag=18; | ||
1622 | public bool HasBbd{ get {return super.BbdCount>=6;} } | ||
1623 | public PBJ.BoundingBox3d3f Bbd{ get { | ||
1624 | int index=0; | ||
1625 | if (HasBbd) { | ||
1626 | return PBJ._PBJ.CastBoundingbox3d3f(super.GetBbd(index*6+0),super.GetBbd(index*6+1),super.GetBbd(index*6+2),super.GetBbd(index*6+3),super.GetBbd(index*6+4),super.GetBbd(index*6+5)); | ||
1627 | } else { | ||
1628 | return PBJ._PBJ.CastBoundingbox3d3f(); | ||
1629 | } | ||
1630 | } | ||
1631 | set { | ||
1632 | super.ClearBbd(); | ||
1633 | double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3d3f(value); | ||
1634 | super.AddBbd(_PBJtempArray[0]); | ||
1635 | super.AddBbd(_PBJtempArray[1]); | ||
1636 | super.AddBbd(_PBJtempArray[2]); | ||
1637 | super.AddBbd(_PBJtempArray[3]); | ||
1638 | super.AddBbd(_PBJtempArray[4]); | ||
1639 | super.AddBbd(_PBJtempArray[5]); | ||
1640 | } | ||
1641 | } | ||
1642 | public Builder ClearE32() { super.ClearE32();return this;} | ||
1643 | public const int E32FieldTag=19; | ||
1644 | public bool HasE32{ get {return super.HasE32;} } | ||
1645 | public Types.Enum32 E32{ get { | ||
1646 | if (HasE32) { | ||
1647 | return (Types.Enum32)super.E32; | ||
1648 | } else { | ||
1649 | return new Types.Enum32(); | ||
1650 | } | ||
1651 | } | ||
1652 | set { | ||
1653 | super.E32=((_PBJ_Internal.TestMessage.Types.Enum32)value); | ||
1654 | } | ||
1655 | } | ||
1656 | public Builder ClearSubmes() { super.ClearSubmes();return this;} | ||
1657 | public const int SubmesFieldTag=30; | ||
1658 | public bool HasSubmes{ get {return super.HasSubmes;} } | ||
1659 | public Types.SubMessage Submes{ get { | ||
1660 | if (HasSubmes) { | ||
1661 | return new Types.SubMessage(super.Submes); | ||
1662 | } else { | ||
1663 | return new Types.SubMessage(); | ||
1664 | } | ||
1665 | } | ||
1666 | set { | ||
1667 | super.Submes=value._PBJSuper; | ||
1668 | } | ||
1669 | } | ||
1670 | public Builder ClearSubmessers() { super.ClearSubmessers();return this;} | ||
1671 | public Builder SetSubmessers(int index,Types.SubMessage value) { | ||
1672 | super.SetSubmessers(index,value._PBJSuper); | ||
1673 | return this; | ||
1674 | } | ||
1675 | public const int SubmessersFieldTag=31; | ||
1676 | public int SubmessersCount { get { return super.SubmessersCount;} } | ||
1677 | public bool HasSubmessers(int index) {return true;} | ||
1678 | public Types.SubMessage Submessers(int index) { | ||
1679 | return new Types.SubMessage(super.GetSubmessers(index)); | ||
1680 | } | ||
1681 | public Builder AddSubmessers(Types.SubMessage value) { | ||
1682 | super.AddSubmessers(value._PBJSuper); | ||
1683 | return this; | ||
1684 | } | ||
1685 | public Builder ClearSha() { super.ClearSha();return this;} | ||
1686 | public const int ShaFieldTag=32; | ||
1687 | public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} } | ||
1688 | public PBJ.SHA256 Sha{ get { | ||
1689 | if (HasSha) { | ||
1690 | return PBJ._PBJ.CastSha256(super.Sha); | ||
1691 | } else { | ||
1692 | return PBJ._PBJ.CastSha256(); | ||
1693 | } | ||
1694 | } | ||
1695 | set { | ||
1696 | super.Sha=(PBJ._PBJ.Construct(value)); | ||
1697 | } | ||
1698 | } | ||
1699 | public Builder ClearShas() { super.ClearShas();return this;} | ||
1700 | public Builder SetShas(int index, PBJ.SHA256 value) { | ||
1701 | super.SetShas(index,PBJ._PBJ.Construct(value)); | ||
1702 | return this; | ||
1703 | } | ||
1704 | public const int ShasFieldTag=33; | ||
1705 | public int ShasCount { get { return super.ShasCount;} } | ||
1706 | public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));} | ||
1707 | public PBJ.SHA256 Shas(int index) { | ||
1708 | return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index)); | ||
1709 | } | ||
1710 | public Builder AddShas(PBJ.SHA256 value) { | ||
1711 | super.AddShas(PBJ._PBJ.Construct(value)); | ||
1712 | return this; | ||
1713 | } | ||
1714 | public Builder ClearExtmes() { super.ClearExtmes();return this;} | ||
1715 | public const int ExtmesFieldTag=34; | ||
1716 | public bool HasExtmes{ get {return super.HasExtmes;} } | ||
1717 | public ExternalMessage Extmes{ get { | ||
1718 | if (HasExtmes) { | ||
1719 | return new ExternalMessage(super.Extmes); | ||
1720 | } else { | ||
1721 | return new ExternalMessage(); | ||
1722 | } | ||
1723 | } | ||
1724 | set { | ||
1725 | super.Extmes=value._PBJSuper; | ||
1726 | } | ||
1727 | } | ||
1728 | public Builder ClearExtmessers() { super.ClearExtmessers();return this;} | ||
1729 | public Builder SetExtmessers(int index,ExternalMessage value) { | ||
1730 | super.SetExtmessers(index,value._PBJSuper); | ||
1731 | return this; | ||
1732 | } | ||
1733 | public const int ExtmessersFieldTag=35; | ||
1734 | public int ExtmessersCount { get { return super.ExtmessersCount;} } | ||
1735 | public bool HasExtmessers(int index) {return true;} | ||
1736 | public ExternalMessage Extmessers(int index) { | ||
1737 | return new ExternalMessage(super.GetExtmessers(index)); | ||
1738 | } | ||
1739 | public Builder AddExtmessers(ExternalMessage value) { | ||
1740 | super.AddExtmessers(value._PBJSuper); | ||
1741 | return this; | ||
1742 | } | ||
1743 | public Builder ClearExtmesser() { super.ClearExtmesser();return this;} | ||
1744 | public const int ExtmesserFieldTag=36; | ||
1745 | public bool HasExtmesser{ get {return super.HasExtmesser;} } | ||
1746 | public ExternalMessage Extmesser{ get { | ||
1747 | if (HasExtmesser) { | ||
1748 | return new ExternalMessage(super.Extmesser); | ||
1749 | } else { | ||
1750 | return new ExternalMessage(); | ||
1751 | } | ||
1752 | } | ||
1753 | set { | ||
1754 | super.Extmesser=value._PBJSuper; | ||
1755 | } | ||
1756 | } | ||
1757 | } | ||
1758 | } | ||
1759 | } | ||
1760 | namespace Sirikata.PB { | ||
1761 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Time.cs b/OpenSim/Client/Sirikata/Protocol/Time.cs deleted file mode 100644 index 4ad49cc..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Time.cs +++ /dev/null | |||
@@ -1,454 +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.Network.Protocol._PBJ_Internal { | ||
8 | |||
9 | public static partial class Time { | ||
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_Network_Protocol__PBJ_Internal_TimeSync__Descriptor; | ||
17 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync, global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.Builder> internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__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 Time() { | ||
26 | byte[] descriptorData = global::System.Convert.FromBase64String( | ||
27 | "CgpUaW1lLnByb3RvEidTaXJpa2F0YS5OZXR3b3JrLlByb3RvY29sLl9QQkpf" + | ||
28 | "SW50ZXJuYWwirQEKCFRpbWVTeW5jEhMKC2NsaWVudF90aW1lGAkgASgGEhMK" + | ||
29 | "C3NlcnZlcl90aW1lGAogASgGEhIKCnN5bmNfcm91bmQYCyABKAQSFgoOcmV0" + | ||
30 | "dXJuX29wdGlvbnMYDiABKA0SEwoKcm91bmRfdHJpcBiBFCABKAYiNgoNUmV0" + | ||
31 | "dXJuT3B0aW9ucxISCg5SRVBMWV9SRUxJQUJMRRABEhEKDVJFUExZX09SREVS" + | ||
32 | "RUQQAg=="); | ||
33 | pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | ||
34 | descriptor = root; | ||
35 | internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor = Descriptor.MessageTypes[0]; | ||
36 | internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable = | ||
37 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync, global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.Builder>(internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor, | ||
38 | new string[] { "ClientTime", "ServerTime", "SyncRound", "ReturnOptions", "RoundTrip", }); | ||
39 | return null; | ||
40 | }; | ||
41 | pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | ||
42 | new pbd::FileDescriptor[] { | ||
43 | }, assigner); | ||
44 | } | ||
45 | #endregion | ||
46 | |||
47 | } | ||
48 | #region Messages | ||
49 | public sealed partial class TimeSync : pb::GeneratedMessage<TimeSync, TimeSync.Builder> { | ||
50 | private static readonly TimeSync defaultInstance = new Builder().BuildPartial(); | ||
51 | public static TimeSync DefaultInstance { | ||
52 | get { return defaultInstance; } | ||
53 | } | ||
54 | |||
55 | public override TimeSync DefaultInstanceForType { | ||
56 | get { return defaultInstance; } | ||
57 | } | ||
58 | |||
59 | protected override TimeSync ThisMessage { | ||
60 | get { return this; } | ||
61 | } | ||
62 | |||
63 | public static pbd::MessageDescriptor Descriptor { | ||
64 | get { return global::Sirikata.Network.Protocol._PBJ_Internal.Time.internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__Descriptor; } | ||
65 | } | ||
66 | |||
67 | protected override pb::FieldAccess.FieldAccessorTable<TimeSync, TimeSync.Builder> InternalFieldAccessors { | ||
68 | get { return global::Sirikata.Network.Protocol._PBJ_Internal.Time.internal__static_Sirikata_Network_Protocol__PBJ_Internal_TimeSync__FieldAccessorTable; } | ||
69 | } | ||
70 | |||
71 | #region Nested types | ||
72 | public static class Types { | ||
73 | public enum ReturnOptions { | ||
74 | REPLY_RELIABLE = 1, | ||
75 | REPLY_ORDERED = 2, | ||
76 | } | ||
77 | |||
78 | } | ||
79 | #endregion | ||
80 | |||
81 | public const int ClientTimeFieldNumber = 9; | ||
82 | private bool hasClientTime; | ||
83 | private ulong clientTime_ = 0; | ||
84 | public bool HasClientTime { | ||
85 | get { return hasClientTime; } | ||
86 | } | ||
87 | [global::System.CLSCompliant(false)] | ||
88 | public ulong ClientTime { | ||
89 | get { return clientTime_; } | ||
90 | } | ||
91 | |||
92 | public const int ServerTimeFieldNumber = 10; | ||
93 | private bool hasServerTime; | ||
94 | private ulong serverTime_ = 0; | ||
95 | public bool HasServerTime { | ||
96 | get { return hasServerTime; } | ||
97 | } | ||
98 | [global::System.CLSCompliant(false)] | ||
99 | public ulong ServerTime { | ||
100 | get { return serverTime_; } | ||
101 | } | ||
102 | |||
103 | public const int SyncRoundFieldNumber = 11; | ||
104 | private bool hasSyncRound; | ||
105 | private ulong syncRound_ = 0UL; | ||
106 | public bool HasSyncRound { | ||
107 | get { return hasSyncRound; } | ||
108 | } | ||
109 | [global::System.CLSCompliant(false)] | ||
110 | public ulong SyncRound { | ||
111 | get { return syncRound_; } | ||
112 | } | ||
113 | |||
114 | public const int ReturnOptionsFieldNumber = 14; | ||
115 | private bool hasReturnOptions; | ||
116 | private uint returnOptions_ = 0; | ||
117 | public bool HasReturnOptions { | ||
118 | get { return hasReturnOptions; } | ||
119 | } | ||
120 | [global::System.CLSCompliant(false)] | ||
121 | public uint ReturnOptions { | ||
122 | get { return returnOptions_; } | ||
123 | } | ||
124 | |||
125 | public const int RoundTripFieldNumber = 2561; | ||
126 | private bool hasRoundTrip; | ||
127 | private ulong roundTrip_ = 0; | ||
128 | public bool HasRoundTrip { | ||
129 | get { return hasRoundTrip; } | ||
130 | } | ||
131 | [global::System.CLSCompliant(false)] | ||
132 | public ulong RoundTrip { | ||
133 | get { return roundTrip_; } | ||
134 | } | ||
135 | |||
136 | public override bool IsInitialized { | ||
137 | get { | ||
138 | return true; | ||
139 | } | ||
140 | } | ||
141 | |||
142 | public override void WriteTo(pb::CodedOutputStream output) { | ||
143 | if (HasClientTime) { | ||
144 | output.WriteFixed64(9, ClientTime); | ||
145 | } | ||
146 | if (HasServerTime) { | ||
147 | output.WriteFixed64(10, ServerTime); | ||
148 | } | ||
149 | if (HasSyncRound) { | ||
150 | output.WriteUInt64(11, SyncRound); | ||
151 | } | ||
152 | if (HasReturnOptions) { | ||
153 | output.WriteUInt32(14, ReturnOptions); | ||
154 | } | ||
155 | if (HasRoundTrip) { | ||
156 | output.WriteFixed64(2561, RoundTrip); | ||
157 | } | ||
158 | UnknownFields.WriteTo(output); | ||
159 | } | ||
160 | |||
161 | private int memoizedSerializedSize = -1; | ||
162 | public override int SerializedSize { | ||
163 | get { | ||
164 | int size = memoizedSerializedSize; | ||
165 | if (size != -1) return size; | ||
166 | |||
167 | size = 0; | ||
168 | if (HasClientTime) { | ||
169 | size += pb::CodedOutputStream.ComputeFixed64Size(9, ClientTime); | ||
170 | } | ||
171 | if (HasServerTime) { | ||
172 | size += pb::CodedOutputStream.ComputeFixed64Size(10, ServerTime); | ||
173 | } | ||
174 | if (HasSyncRound) { | ||
175 | size += pb::CodedOutputStream.ComputeUInt64Size(11, SyncRound); | ||
176 | } | ||
177 | if (HasReturnOptions) { | ||
178 | size += pb::CodedOutputStream.ComputeUInt32Size(14, ReturnOptions); | ||
179 | } | ||
180 | if (HasRoundTrip) { | ||
181 | size += pb::CodedOutputStream.ComputeFixed64Size(2561, RoundTrip); | ||
182 | } | ||
183 | size += UnknownFields.SerializedSize; | ||
184 | memoizedSerializedSize = size; | ||
185 | return size; | ||
186 | } | ||
187 | } | ||
188 | |||
189 | public static TimeSync ParseFrom(pb::ByteString data) { | ||
190 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
191 | } | ||
192 | public static TimeSync ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
193 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
194 | } | ||
195 | public static TimeSync ParseFrom(byte[] data) { | ||
196 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
197 | } | ||
198 | public static TimeSync ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
199 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
200 | } | ||
201 | public static TimeSync ParseFrom(global::System.IO.Stream input) { | ||
202 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
203 | } | ||
204 | public static TimeSync ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
205 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
206 | } | ||
207 | public static TimeSync ParseDelimitedFrom(global::System.IO.Stream input) { | ||
208 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
209 | } | ||
210 | public static TimeSync ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
211 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
212 | } | ||
213 | public static TimeSync ParseFrom(pb::CodedInputStream input) { | ||
214 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
215 | } | ||
216 | public static TimeSync ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
217 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
218 | } | ||
219 | public static Builder CreateBuilder() { return new Builder(); } | ||
220 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
221 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
222 | public static Builder CreateBuilder(TimeSync prototype) { | ||
223 | return (Builder) new Builder().MergeFrom(prototype); | ||
224 | } | ||
225 | |||
226 | public sealed partial class Builder : pb::GeneratedBuilder<TimeSync, Builder> { | ||
227 | protected override Builder ThisBuilder { | ||
228 | get { return this; } | ||
229 | } | ||
230 | public Builder() {} | ||
231 | |||
232 | TimeSync result = new TimeSync(); | ||
233 | |||
234 | protected override TimeSync MessageBeingBuilt { | ||
235 | get { return result; } | ||
236 | } | ||
237 | |||
238 | public override Builder Clear() { | ||
239 | result = new TimeSync(); | ||
240 | return this; | ||
241 | } | ||
242 | |||
243 | public override Builder Clone() { | ||
244 | return new Builder().MergeFrom(result); | ||
245 | } | ||
246 | |||
247 | public override pbd::MessageDescriptor DescriptorForType { | ||
248 | get { return global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.Descriptor; } | ||
249 | } | ||
250 | |||
251 | public override TimeSync DefaultInstanceForType { | ||
252 | get { return global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.DefaultInstance; } | ||
253 | } | ||
254 | |||
255 | public override TimeSync BuildPartial() { | ||
256 | if (result == null) { | ||
257 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
258 | } | ||
259 | TimeSync returnMe = result; | ||
260 | result = null; | ||
261 | return returnMe; | ||
262 | } | ||
263 | |||
264 | public override Builder MergeFrom(pb::IMessage other) { | ||
265 | if (other is TimeSync) { | ||
266 | return MergeFrom((TimeSync) other); | ||
267 | } else { | ||
268 | base.MergeFrom(other); | ||
269 | return this; | ||
270 | } | ||
271 | } | ||
272 | |||
273 | public override Builder MergeFrom(TimeSync other) { | ||
274 | if (other == global::Sirikata.Network.Protocol._PBJ_Internal.TimeSync.DefaultInstance) return this; | ||
275 | if (other.HasClientTime) { | ||
276 | ClientTime = other.ClientTime; | ||
277 | } | ||
278 | if (other.HasServerTime) { | ||
279 | ServerTime = other.ServerTime; | ||
280 | } | ||
281 | if (other.HasSyncRound) { | ||
282 | SyncRound = other.SyncRound; | ||
283 | } | ||
284 | if (other.HasReturnOptions) { | ||
285 | ReturnOptions = other.ReturnOptions; | ||
286 | } | ||
287 | if (other.HasRoundTrip) { | ||
288 | RoundTrip = other.RoundTrip; | ||
289 | } | ||
290 | this.MergeUnknownFields(other.UnknownFields); | ||
291 | return this; | ||
292 | } | ||
293 | |||
294 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
295 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
296 | } | ||
297 | |||
298 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
299 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
300 | while (true) { | ||
301 | uint tag = input.ReadTag(); | ||
302 | switch (tag) { | ||
303 | case 0: { | ||
304 | if (unknownFields != null) { | ||
305 | this.UnknownFields = unknownFields.Build(); | ||
306 | } | ||
307 | return this; | ||
308 | } | ||
309 | default: { | ||
310 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
311 | if (unknownFields != null) { | ||
312 | this.UnknownFields = unknownFields.Build(); | ||
313 | } | ||
314 | return this; | ||
315 | } | ||
316 | if (unknownFields == null) { | ||
317 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
318 | } | ||
319 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
320 | break; | ||
321 | } | ||
322 | case 73: { | ||
323 | ClientTime = input.ReadFixed64(); | ||
324 | break; | ||
325 | } | ||
326 | case 81: { | ||
327 | ServerTime = input.ReadFixed64(); | ||
328 | break; | ||
329 | } | ||
330 | case 88: { | ||
331 | SyncRound = input.ReadUInt64(); | ||
332 | break; | ||
333 | } | ||
334 | case 112: { | ||
335 | ReturnOptions = input.ReadUInt32(); | ||
336 | break; | ||
337 | } | ||
338 | case 20489: { | ||
339 | RoundTrip = input.ReadFixed64(); | ||
340 | break; | ||
341 | } | ||
342 | } | ||
343 | } | ||
344 | } | ||
345 | |||
346 | |||
347 | public bool HasClientTime { | ||
348 | get { return result.HasClientTime; } | ||
349 | } | ||
350 | [global::System.CLSCompliant(false)] | ||
351 | public ulong ClientTime { | ||
352 | get { return result.ClientTime; } | ||
353 | set { SetClientTime(value); } | ||
354 | } | ||
355 | [global::System.CLSCompliant(false)] | ||
356 | public Builder SetClientTime(ulong value) { | ||
357 | result.hasClientTime = true; | ||
358 | result.clientTime_ = value; | ||
359 | return this; | ||
360 | } | ||
361 | public Builder ClearClientTime() { | ||
362 | result.hasClientTime = false; | ||
363 | result.clientTime_ = 0; | ||
364 | return this; | ||
365 | } | ||
366 | |||
367 | public bool HasServerTime { | ||
368 | get { return result.HasServerTime; } | ||
369 | } | ||
370 | [global::System.CLSCompliant(false)] | ||
371 | public ulong ServerTime { | ||
372 | get { return result.ServerTime; } | ||
373 | set { SetServerTime(value); } | ||
374 | } | ||
375 | [global::System.CLSCompliant(false)] | ||
376 | public Builder SetServerTime(ulong value) { | ||
377 | result.hasServerTime = true; | ||
378 | result.serverTime_ = value; | ||
379 | return this; | ||
380 | } | ||
381 | public Builder ClearServerTime() { | ||
382 | result.hasServerTime = false; | ||
383 | result.serverTime_ = 0; | ||
384 | return this; | ||
385 | } | ||
386 | |||
387 | public bool HasSyncRound { | ||
388 | get { return result.HasSyncRound; } | ||
389 | } | ||
390 | [global::System.CLSCompliant(false)] | ||
391 | public ulong SyncRound { | ||
392 | get { return result.SyncRound; } | ||
393 | set { SetSyncRound(value); } | ||
394 | } | ||
395 | [global::System.CLSCompliant(false)] | ||
396 | public Builder SetSyncRound(ulong value) { | ||
397 | result.hasSyncRound = true; | ||
398 | result.syncRound_ = value; | ||
399 | return this; | ||
400 | } | ||
401 | public Builder ClearSyncRound() { | ||
402 | result.hasSyncRound = false; | ||
403 | result.syncRound_ = 0UL; | ||
404 | return this; | ||
405 | } | ||
406 | |||
407 | public bool HasReturnOptions { | ||
408 | get { return result.HasReturnOptions; } | ||
409 | } | ||
410 | [global::System.CLSCompliant(false)] | ||
411 | public uint ReturnOptions { | ||
412 | get { return result.ReturnOptions; } | ||
413 | set { SetReturnOptions(value); } | ||
414 | } | ||
415 | [global::System.CLSCompliant(false)] | ||
416 | public Builder SetReturnOptions(uint value) { | ||
417 | result.hasReturnOptions = true; | ||
418 | result.returnOptions_ = value; | ||
419 | return this; | ||
420 | } | ||
421 | public Builder ClearReturnOptions() { | ||
422 | result.hasReturnOptions = false; | ||
423 | result.returnOptions_ = 0; | ||
424 | return this; | ||
425 | } | ||
426 | |||
427 | public bool HasRoundTrip { | ||
428 | get { return result.HasRoundTrip; } | ||
429 | } | ||
430 | [global::System.CLSCompliant(false)] | ||
431 | public ulong RoundTrip { | ||
432 | get { return result.RoundTrip; } | ||
433 | set { SetRoundTrip(value); } | ||
434 | } | ||
435 | [global::System.CLSCompliant(false)] | ||
436 | public Builder SetRoundTrip(ulong value) { | ||
437 | result.hasRoundTrip = true; | ||
438 | result.roundTrip_ = value; | ||
439 | return this; | ||
440 | } | ||
441 | public Builder ClearRoundTrip() { | ||
442 | result.hasRoundTrip = false; | ||
443 | result.roundTrip_ = 0; | ||
444 | return this; | ||
445 | } | ||
446 | } | ||
447 | static TimeSync() { | ||
448 | object.ReferenceEquals(global::Sirikata.Network.Protocol._PBJ_Internal.Time.Descriptor, null); | ||
449 | } | ||
450 | } | ||
451 | |||
452 | #endregion | ||
453 | |||
454 | } | ||
diff --git a/OpenSim/Client/Sirikata/Protocol/Time.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Time.pbj.cs deleted file mode 100644 index 15b4ae7..0000000 --- a/OpenSim/Client/Sirikata/Protocol/Time.pbj.cs +++ /dev/null | |||
@@ -1,245 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace Sirikata.Network.Protocol { | ||
31 | public class TimeSync : PBJ.IMessage { | ||
32 | protected _PBJ_Internal.TimeSync super; | ||
33 | public _PBJ_Internal.TimeSync _PBJSuper{ get { return super;} } | ||
34 | public TimeSync() { | ||
35 | super=new _PBJ_Internal.TimeSync(); | ||
36 | } | ||
37 | public TimeSync(_PBJ_Internal.TimeSync reference) { | ||
38 | super=reference; | ||
39 | } | ||
40 | public static TimeSync defaultInstance= new TimeSync (_PBJ_Internal.TimeSync.DefaultInstance); | ||
41 | public static TimeSync DefaultInstance{ | ||
42 | get {return defaultInstance;} | ||
43 | } | ||
44 | public static pbd.MessageDescriptor Descriptor { | ||
45 | get { return _PBJ_Internal.TimeSync.Descriptor; } } | ||
46 | public static class Types { | ||
47 | public enum ReturnOptions { | ||
48 | REPLY_RELIABLE=_PBJ_Internal.TimeSync.Types.ReturnOptions.REPLY_RELIABLE, | ||
49 | REPLY_ORDERED=_PBJ_Internal.TimeSync.Types.ReturnOptions.REPLY_ORDERED | ||
50 | }; | ||
51 | } | ||
52 | public static bool WithinReservedFieldTagRange(int field_tag) { | ||
53 | return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912); | ||
54 | } | ||
55 | public static bool WithinExtensionFieldTagRange(int field_tag) { | ||
56 | return false; | ||
57 | } | ||
58 | public const int ClientTimeFieldTag=9; | ||
59 | public bool HasClientTime{ get {return super.HasClientTime&&PBJ._PBJ.ValidateTime(super.ClientTime);} } | ||
60 | public PBJ.Time ClientTime{ get { | ||
61 | if (HasClientTime) { | ||
62 | return PBJ._PBJ.CastTime(super.ClientTime); | ||
63 | } else { | ||
64 | return PBJ._PBJ.CastTime(); | ||
65 | } | ||
66 | } | ||
67 | } | ||
68 | public const int ServerTimeFieldTag=10; | ||
69 | public bool HasServerTime{ get {return super.HasServerTime&&PBJ._PBJ.ValidateTime(super.ServerTime);} } | ||
70 | public PBJ.Time ServerTime{ get { | ||
71 | if (HasServerTime) { | ||
72 | return PBJ._PBJ.CastTime(super.ServerTime); | ||
73 | } else { | ||
74 | return PBJ._PBJ.CastTime(); | ||
75 | } | ||
76 | } | ||
77 | } | ||
78 | public const int SyncRoundFieldTag=11; | ||
79 | public bool HasSyncRound{ get {return super.HasSyncRound&&PBJ._PBJ.ValidateUint64(super.SyncRound);} } | ||
80 | public ulong SyncRound{ get { | ||
81 | if (HasSyncRound) { | ||
82 | return PBJ._PBJ.CastUint64(super.SyncRound); | ||
83 | } else { | ||
84 | return PBJ._PBJ.CastUint64(); | ||
85 | } | ||
86 | } | ||
87 | } | ||
88 | public const int ReturnOptionsFieldTag=14; | ||
89 | public bool HasReturnOptions { get { | ||
90 | if (!super.HasReturnOptions) return false; | ||
91 | return PBJ._PBJ.ValidateFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); | ||
92 | } } | ||
93 | public uint ReturnOptions{ get { | ||
94 | if (HasReturnOptions) { | ||
95 | return (uint)PBJ._PBJ.CastFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); | ||
96 | } else { | ||
97 | return (uint)PBJ._PBJ.CastFlags((ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); | ||
98 | } | ||
99 | } | ||
100 | } | ||
101 | public const int RoundTripFieldTag=2561; | ||
102 | public bool HasRoundTrip{ get {return super.HasRoundTrip&&PBJ._PBJ.ValidateTime(super.RoundTrip);} } | ||
103 | public PBJ.Time RoundTrip{ get { | ||
104 | if (HasRoundTrip) { | ||
105 | return PBJ._PBJ.CastTime(super.RoundTrip); | ||
106 | } else { | ||
107 | return PBJ._PBJ.CastTime(); | ||
108 | } | ||
109 | } | ||
110 | } | ||
111 | public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } } | ||
112 | public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); } | ||
113 | public static Builder CreateBuilder() { return new Builder(); } | ||
114 | public static Builder CreateBuilder(TimeSync prototype) { | ||
115 | return (Builder)new Builder().MergeFrom(prototype); | ||
116 | } | ||
117 | public static TimeSync ParseFrom(pb::ByteString data) { | ||
118 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); | ||
119 | } | ||
120 | public static TimeSync ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) { | ||
121 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); | ||
122 | } | ||
123 | public static TimeSync ParseFrom(byte[] data) { | ||
124 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); | ||
125 | } | ||
126 | public static TimeSync ParseFrom(byte[] data, pb::ExtensionRegistry er) { | ||
127 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); | ||
128 | } | ||
129 | public static TimeSync ParseFrom(global::System.IO.Stream data) { | ||
130 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); | ||
131 | } | ||
132 | public static TimeSync ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) { | ||
133 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); | ||
134 | } | ||
135 | public static TimeSync ParseFrom(pb::CodedInputStream data) { | ||
136 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data)); | ||
137 | } | ||
138 | public static TimeSync ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) { | ||
139 | return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er)); | ||
140 | } | ||
141 | protected override bool _HasAllPBJFields{ get { | ||
142 | return true | ||
143 | ; | ||
144 | } } | ||
145 | public bool IsInitialized { get { | ||
146 | return super.IsInitialized&&_HasAllPBJFields; | ||
147 | } } | ||
148 | public class Builder : global::PBJ.IMessage.IBuilder{ | ||
149 | protected override bool _HasAllPBJFields{ get { | ||
150 | return true | ||
151 | ; | ||
152 | } } | ||
153 | public bool IsInitialized { get { | ||
154 | return super.IsInitialized&&_HasAllPBJFields; | ||
155 | } } | ||
156 | protected _PBJ_Internal.TimeSync.Builder super; | ||
157 | public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } } | ||
158 | public _PBJ_Internal.TimeSync.Builder _PBJSuper{ get { return super;} } | ||
159 | public Builder() {super = new _PBJ_Internal.TimeSync.Builder();} | ||
160 | public Builder(_PBJ_Internal.TimeSync.Builder other) { | ||
161 | super=other; | ||
162 | } | ||
163 | public Builder Clone() {return new Builder(super.Clone());} | ||
164 | public Builder MergeFrom(TimeSync prototype) { super.MergeFrom(prototype._PBJSuper);return this;} | ||
165 | public Builder Clear() {super.Clear();return this;} | ||
166 | public TimeSync BuildPartial() {return new TimeSync(super.BuildPartial());} | ||
167 | public TimeSync Build() {if (_HasAllPBJFields) return new TimeSync(super.Build());return null;} | ||
168 | public pbd::MessageDescriptor DescriptorForType { | ||
169 | get { return TimeSync.Descriptor; } } | ||
170 | public Builder ClearClientTime() { super.ClearClientTime();return this;} | ||
171 | public const int ClientTimeFieldTag=9; | ||
172 | public bool HasClientTime{ get {return super.HasClientTime&&PBJ._PBJ.ValidateTime(super.ClientTime);} } | ||
173 | public PBJ.Time ClientTime{ get { | ||
174 | if (HasClientTime) { | ||
175 | return PBJ._PBJ.CastTime(super.ClientTime); | ||
176 | } else { | ||
177 | return PBJ._PBJ.CastTime(); | ||
178 | } | ||
179 | } | ||
180 | set { | ||
181 | super.ClientTime=(PBJ._PBJ.Construct(value)); | ||
182 | } | ||
183 | } | ||
184 | public Builder ClearServerTime() { super.ClearServerTime();return this;} | ||
185 | public const int ServerTimeFieldTag=10; | ||
186 | public bool HasServerTime{ get {return super.HasServerTime&&PBJ._PBJ.ValidateTime(super.ServerTime);} } | ||
187 | public PBJ.Time ServerTime{ get { | ||
188 | if (HasServerTime) { | ||
189 | return PBJ._PBJ.CastTime(super.ServerTime); | ||
190 | } else { | ||
191 | return PBJ._PBJ.CastTime(); | ||
192 | } | ||
193 | } | ||
194 | set { | ||
195 | super.ServerTime=(PBJ._PBJ.Construct(value)); | ||
196 | } | ||
197 | } | ||
198 | public Builder ClearSyncRound() { super.ClearSyncRound();return this;} | ||
199 | public const int SyncRoundFieldTag=11; | ||
200 | public bool HasSyncRound{ get {return super.HasSyncRound&&PBJ._PBJ.ValidateUint64(super.SyncRound);} } | ||
201 | public ulong SyncRound{ get { | ||
202 | if (HasSyncRound) { | ||
203 | return PBJ._PBJ.CastUint64(super.SyncRound); | ||
204 | } else { | ||
205 | return PBJ._PBJ.CastUint64(); | ||
206 | } | ||
207 | } | ||
208 | set { | ||
209 | super.SyncRound=(PBJ._PBJ.Construct(value)); | ||
210 | } | ||
211 | } | ||
212 | public Builder ClearReturnOptions() { super.ClearReturnOptions();return this;} | ||
213 | public const int ReturnOptionsFieldTag=14; | ||
214 | public bool HasReturnOptions { get { | ||
215 | if (!super.HasReturnOptions) return false; | ||
216 | return PBJ._PBJ.ValidateFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); | ||
217 | } } | ||
218 | public uint ReturnOptions{ get { | ||
219 | if (HasReturnOptions) { | ||
220 | return (uint)PBJ._PBJ.CastFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); | ||
221 | } else { | ||
222 | return (uint)PBJ._PBJ.CastFlags((ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED); | ||
223 | } | ||
224 | } | ||
225 | set { | ||
226 | super.ReturnOptions=((value)); | ||
227 | } | ||
228 | } | ||
229 | public Builder ClearRoundTrip() { super.ClearRoundTrip();return this;} | ||
230 | public const int RoundTripFieldTag=2561; | ||
231 | public bool HasRoundTrip{ get {return super.HasRoundTrip&&PBJ._PBJ.ValidateTime(super.RoundTrip);} } | ||
232 | public PBJ.Time RoundTrip{ get { | ||
233 | if (HasRoundTrip) { | ||
234 | return PBJ._PBJ.CastTime(super.RoundTrip); | ||
235 | } else { | ||
236 | return PBJ._PBJ.CastTime(); | ||
237 | } | ||
238 | } | ||
239 | set { | ||
240 | super.RoundTrip=(PBJ._PBJ.Construct(value)); | ||
241 | } | ||
242 | } | ||
243 | } | ||
244 | } | ||
245 | } | ||