aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Client/Sirikata/Protocol
diff options
context:
space:
mode:
authorAdam Frisby2009-12-27 15:03:10 +1100
committerAdam Frisby2009-12-27 15:03:10 +1100
commitfd777cc7b964a302f335ad91735f02554582c648 (patch)
tree4b448a6ea13b3074a5c54beed0a8744127b2930b /OpenSim/Client/Sirikata/Protocol
parent* Adding Google.ProtocolBuffers.dll dependency (BSD licensed) (diff)
downloadopensim-SC_OLD-fd777cc7b964a302f335ad91735f02554582c648.zip
opensim-SC_OLD-fd777cc7b964a302f335ad91735f02554582c648.tar.gz
opensim-SC_OLD-fd777cc7b964a302f335ad91735f02554582c648.tar.bz2
opensim-SC_OLD-fd777cc7b964a302f335ad91735f02554582c648.tar.xz
* Implements Sirikata ClientStack Module
* Just a stub (imports all the sirikata protocol, and that's about it.)
Diffstat (limited to 'OpenSim/Client/Sirikata/Protocol')
-rw-r--r--OpenSim/Client/Sirikata/Protocol/MessageHeader.cs630
-rw-r--r--OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs312
-rw-r--r--OpenSim/Client/Sirikata/Protocol/PBJ.cs2077
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Persistence.cs3299
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs1516
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Physics.cs840
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs394
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Sirikata.cs8074
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs3907
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Subscription.cs856
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs404
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Test.cs3773
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Test.pbj.cs1734
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Time.cs454
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Time.pbj.cs218
15 files changed, 28488 insertions, 0 deletions
diff --git a/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs b/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs
new file mode 100644
index 0000000..22e10f7
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs
@@ -0,0 +1,630 @@
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2
3using pb = global::Google.ProtocolBuffers;
4using pbc = global::Google.ProtocolBuffers.Collections;
5using pbd = global::Google.ProtocolBuffers.Descriptors;
6using scg = global::System.Collections.Generic;
7namespace 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
new file mode 100644
index 0000000..eadb43b
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/MessageHeader.pbj.cs
@@ -0,0 +1,312 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.Protocol {
4 public class Header : PBJ.IMessage {
5 protected _PBJ_Internal.Header super;
6 public _PBJ_Internal.Header _PBJSuper{ get { return super;} }
7 public Header() {
8 super=new _PBJ_Internal.Header();
9 }
10 public Header(_PBJ_Internal.Header reference) {
11 super=reference;
12 }
13 public static Header defaultInstance= new Header (_PBJ_Internal.Header.DefaultInstance);
14 public static Header DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.Header.Descriptor; } }
19 public static class Types {
20 public enum ReturnStatus {
21 SUCCESS=_PBJ_Internal.Header.Types.ReturnStatus.SUCCESS,
22 NETWORK_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.NETWORK_FAILURE,
23 TIMEOUT_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.TIMEOUT_FAILURE,
24 PROTOCOL_ERROR=_PBJ_Internal.Header.Types.ReturnStatus.PROTOCOL_ERROR,
25 PORT_FAILURE=_PBJ_Internal.Header.Types.ReturnStatus.PORT_FAILURE,
26 UNKNOWN_OBJECT=_PBJ_Internal.Header.Types.ReturnStatus.UNKNOWN_OBJECT
27 };
28 }
29 public static bool WithinReservedFieldTagRange(int field_tag) {
30 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
31 }
32 public static bool WithinExtensionFieldTagRange(int field_tag) {
33 return false;
34 }
35 public const int SourceObjectFieldTag=1;
36 public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} }
37 public PBJ.UUID SourceObject{ get {
38 if (HasSourceObject) {
39 return PBJ._PBJ.CastUuid(super.SourceObject);
40 } else {
41 return PBJ._PBJ.CastUuid();
42 }
43 }
44 }
45 public const int SourcePortFieldTag=3;
46 public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} }
47 public uint SourcePort{ get {
48 if (HasSourcePort) {
49 return PBJ._PBJ.CastUint32(super.SourcePort);
50 } else {
51 return PBJ._PBJ.CastUint32();
52 }
53 }
54 }
55 public const int SourceSpaceFieldTag=1536;
56 public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} }
57 public PBJ.UUID SourceSpace{ get {
58 if (HasSourceSpace) {
59 return PBJ._PBJ.CastUuid(super.SourceSpace);
60 } else {
61 return PBJ._PBJ.CastUuid();
62 }
63 }
64 }
65 public const int DestinationObjectFieldTag=2;
66 public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} }
67 public PBJ.UUID DestinationObject{ get {
68 if (HasDestinationObject) {
69 return PBJ._PBJ.CastUuid(super.DestinationObject);
70 } else {
71 return PBJ._PBJ.CastUuid();
72 }
73 }
74 }
75 public const int DestinationPortFieldTag=4;
76 public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} }
77 public uint DestinationPort{ get {
78 if (HasDestinationPort) {
79 return PBJ._PBJ.CastUint32(super.DestinationPort);
80 } else {
81 return PBJ._PBJ.CastUint32();
82 }
83 }
84 }
85 public const int DestinationSpaceFieldTag=1537;
86 public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} }
87 public PBJ.UUID DestinationSpace{ get {
88 if (HasDestinationSpace) {
89 return PBJ._PBJ.CastUuid(super.DestinationSpace);
90 } else {
91 return PBJ._PBJ.CastUuid();
92 }
93 }
94 }
95 public const int IdFieldTag=7;
96 public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} }
97 public long Id{ get {
98 if (HasId) {
99 return PBJ._PBJ.CastInt64(super.Id);
100 } else {
101 return PBJ._PBJ.CastInt64();
102 }
103 }
104 }
105 public const int ReplyIdFieldTag=8;
106 public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} }
107 public long ReplyId{ get {
108 if (HasReplyId) {
109 return PBJ._PBJ.CastInt64(super.ReplyId);
110 } else {
111 return PBJ._PBJ.CastInt64();
112 }
113 }
114 }
115 public const int ReturnStatusFieldTag=1792;
116 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
117 public Types.ReturnStatus ReturnStatus{ get {
118 if (HasReturnStatus) {
119 return (Types.ReturnStatus)super.ReturnStatus;
120 } else {
121 return new Types.ReturnStatus();
122 }
123 }
124 }
125 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
126 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
127 public static Builder CreateBuilder() { return new Builder(); }
128 public static Builder CreateBuilder(Header prototype) {
129 return (Builder)new Builder().MergeFrom(prototype);
130 }
131 public static Header ParseFrom(pb::ByteString data) {
132 return new Header(_PBJ_Internal.Header.ParseFrom(data));
133 }
134 public static Header ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
135 return new Header(_PBJ_Internal.Header.ParseFrom(data,er));
136 }
137 public static Header ParseFrom(byte[] data) {
138 return new Header(_PBJ_Internal.Header.ParseFrom(data));
139 }
140 public static Header ParseFrom(byte[] data, pb::ExtensionRegistry er) {
141 return new Header(_PBJ_Internal.Header.ParseFrom(data,er));
142 }
143 public static Header ParseFrom(global::System.IO.Stream data) {
144 return new Header(_PBJ_Internal.Header.ParseFrom(data));
145 }
146 public static Header ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
147 return new Header(_PBJ_Internal.Header.ParseFrom(data,er));
148 }
149 public static Header ParseFrom(pb::CodedInputStream data) {
150 return new Header(_PBJ_Internal.Header.ParseFrom(data));
151 }
152 public static Header ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
153 return new Header(_PBJ_Internal.Header.ParseFrom(data,er));
154 }
155 protected override bool _HasAllPBJFields{ get {
156 return true
157 ;
158 } }
159 public bool IsInitialized { get {
160 return super.IsInitialized&&_HasAllPBJFields;
161 } }
162 public class Builder : global::PBJ.IMessage.IBuilder{
163 protected override bool _HasAllPBJFields{ get {
164 return true
165 ;
166 } }
167 public bool IsInitialized { get {
168 return super.IsInitialized&&_HasAllPBJFields;
169 } }
170 protected _PBJ_Internal.Header.Builder super;
171 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
172 public _PBJ_Internal.Header.Builder _PBJSuper{ get { return super;} }
173 public Builder() {super = new _PBJ_Internal.Header.Builder();}
174 public Builder(_PBJ_Internal.Header.Builder other) {
175 super=other;
176 }
177 public Builder Clone() {return new Builder(super.Clone());}
178 public Builder MergeFrom(Header prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
179 public Builder Clear() {super.Clear();return this;}
180 public Header BuildPartial() {return new Header(super.BuildPartial());}
181 public Header Build() {if (_HasAllPBJFields) return new Header(super.Build());return null;}
182 public pbd::MessageDescriptor DescriptorForType {
183 get { return Header.Descriptor; } }
184 public Builder ClearSourceObject() { super.ClearSourceObject();return this;}
185 public const int SourceObjectFieldTag=1;
186 public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} }
187 public PBJ.UUID SourceObject{ get {
188 if (HasSourceObject) {
189 return PBJ._PBJ.CastUuid(super.SourceObject);
190 } else {
191 return PBJ._PBJ.CastUuid();
192 }
193 }
194 set {
195 super.SourceObject=(PBJ._PBJ.Construct(value));
196 }
197 }
198 public Builder ClearSourcePort() { super.ClearSourcePort();return this;}
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 set {
209 super.SourcePort=(PBJ._PBJ.Construct(value));
210 }
211 }
212 public Builder ClearSourceSpace() { super.ClearSourceSpace();return this;}
213 public const int SourceSpaceFieldTag=1536;
214 public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} }
215 public PBJ.UUID SourceSpace{ get {
216 if (HasSourceSpace) {
217 return PBJ._PBJ.CastUuid(super.SourceSpace);
218 } else {
219 return PBJ._PBJ.CastUuid();
220 }
221 }
222 set {
223 super.SourceSpace=(PBJ._PBJ.Construct(value));
224 }
225 }
226 public Builder ClearDestinationObject() { super.ClearDestinationObject();return this;}
227 public const int DestinationObjectFieldTag=2;
228 public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} }
229 public PBJ.UUID DestinationObject{ get {
230 if (HasDestinationObject) {
231 return PBJ._PBJ.CastUuid(super.DestinationObject);
232 } else {
233 return PBJ._PBJ.CastUuid();
234 }
235 }
236 set {
237 super.DestinationObject=(PBJ._PBJ.Construct(value));
238 }
239 }
240 public Builder ClearDestinationPort() { super.ClearDestinationPort();return this;}
241 public const int DestinationPortFieldTag=4;
242 public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} }
243 public uint DestinationPort{ get {
244 if (HasDestinationPort) {
245 return PBJ._PBJ.CastUint32(super.DestinationPort);
246 } else {
247 return PBJ._PBJ.CastUint32();
248 }
249 }
250 set {
251 super.DestinationPort=(PBJ._PBJ.Construct(value));
252 }
253 }
254 public Builder ClearDestinationSpace() { super.ClearDestinationSpace();return this;}
255 public const int DestinationSpaceFieldTag=1537;
256 public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} }
257 public PBJ.UUID DestinationSpace{ get {
258 if (HasDestinationSpace) {
259 return PBJ._PBJ.CastUuid(super.DestinationSpace);
260 } else {
261 return PBJ._PBJ.CastUuid();
262 }
263 }
264 set {
265 super.DestinationSpace=(PBJ._PBJ.Construct(value));
266 }
267 }
268 public Builder ClearId() { super.ClearId();return this;}
269 public const int IdFieldTag=7;
270 public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} }
271 public long Id{ get {
272 if (HasId) {
273 return PBJ._PBJ.CastInt64(super.Id);
274 } else {
275 return PBJ._PBJ.CastInt64();
276 }
277 }
278 set {
279 super.Id=(PBJ._PBJ.Construct(value));
280 }
281 }
282 public Builder ClearReplyId() { super.ClearReplyId();return this;}
283 public const int ReplyIdFieldTag=8;
284 public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} }
285 public long ReplyId{ get {
286 if (HasReplyId) {
287 return PBJ._PBJ.CastInt64(super.ReplyId);
288 } else {
289 return PBJ._PBJ.CastInt64();
290 }
291 }
292 set {
293 super.ReplyId=(PBJ._PBJ.Construct(value));
294 }
295 }
296 public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;}
297 public const int ReturnStatusFieldTag=1792;
298 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
299 public Types.ReturnStatus ReturnStatus{ get {
300 if (HasReturnStatus) {
301 return (Types.ReturnStatus)super.ReturnStatus;
302 } else {
303 return new Types.ReturnStatus();
304 }
305 }
306 set {
307 super.ReturnStatus=((_PBJ_Internal.Header.Types.ReturnStatus)value);
308 }
309 }
310 }
311 }
312}
diff --git a/OpenSim/Client/Sirikata/Protocol/PBJ.cs b/OpenSim/Client/Sirikata/Protocol/PBJ.cs
new file mode 100644
index 0000000..46888b5
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/PBJ.cs
@@ -0,0 +1,2077 @@
1using System;
2namespace PBJ
3{
4
5 public class IMessage
6 {
7 public virtual Google.ProtocolBuffers.IMessage _PBJISuper { get { return null; } }
8 protected virtual bool _HasAllPBJFields { get { return true; } }
9 public void WriteTo(Google.ProtocolBuffers.CodedOutputStream output)
10 {
11 _PBJISuper.WriteTo(output);
12 }
13 public override bool Equals(object other)
14 {
15 return _PBJISuper.Equals(other);
16 }
17 public int SerializedSize { get { return _PBJISuper.SerializedSize; } }
18
19 public override int GetHashCode() { return _PBJISuper.GetHashCode(); }
20
21 public override string ToString()
22 {
23 return _PBJISuper.ToString();
24 }
25 public virtual IBuilder WeakCreateBuilderForType() { return null; }
26 public Google.ProtocolBuffers.ByteString ToByteString()
27 {
28 return _PBJISuper.ToByteString();
29 }
30 public byte[] ToByteArray()
31 {
32 return _PBJISuper.ToByteArray();
33 }
34 public void WriteTo(global::System.IO.Stream output)
35 {
36 _PBJISuper.WriteTo(output);
37 }
38 // Google.ProtocolBuffers.MessageDescriptor DescriptorForType { get {return _PBJISuper.DescriptorForType;} }
39 public Google.ProtocolBuffers.UnknownFieldSet UnknownFields { get { return _PBJISuper.UnknownFields; } }
40 public class IBuilder
41 {
42 public virtual Google.ProtocolBuffers.IBuilder _PBJISuper { get { return null; } }
43 protected virtual bool _HasAllPBJFields { get { return true; } }
44 }
45 }
46
47 public struct Vector2f
48 {
49
50 public float x;
51 public float y;
52
53
54 public Vector2f(float _x, float _y)
55 {
56 x = _x; y = _y;
57 }
58
59 public Vector2f(Vector2f cpy)
60 {
61 x = cpy.x; y = cpy.y;
62 }
63
64
65 public Vector2f Negate()
66 {
67 return new Vector2f(-x, -y);
68 }
69
70 public Vector2f Add(Vector2f rhs)
71 {
72 return new Vector2f(x + rhs.x, y + rhs.y);
73 }
74
75 public Vector2f Subtract(Vector2f rhs)
76 {
77 return new Vector2f(x - rhs.x, y - rhs.y);
78 }
79
80 public Vector2f Multiply(Vector2f rhs)
81 {
82 return new Vector2f(x * rhs.x, y * rhs.y);
83 }
84
85 public Vector2f Multiply(float s)
86 {
87 return new Vector2f(x * s, y * s);
88 }
89
90 public Vector2f Divide(Vector2f rhs)
91 {
92 return new Vector2f(x / rhs.x, y / rhs.y);
93 }
94
95 public Vector2f Divide(float s)
96 {
97 return new Vector2f(x / s, y / s);
98 }
99
100 public float Dot(Vector2f rhs)
101 {
102 return (x * rhs.x + y * rhs.y);
103 }
104
105 public void Normalize()
106 {
107 float len = Length;
108 if (len != 0.0)
109 {
110 x /= len; y /= len;
111 }
112 }
113
114 public Vector2f Normalized
115 {
116 get
117 {
118 Vector2f normed = new Vector2f(this);
119 normed.Normalize();
120 return normed;
121 }
122 }
123
124 public float SquaredLength
125 {
126 get
127 {
128 return (x * x + y * y);
129 }
130 }
131 public float Length
132 {
133 get
134 {
135 return (float)Math.Sqrt(SquaredLength);
136 }
137 }
138
139
140 public override string ToString()
141 {
142 return String.Format("<{0}, {1}>", x, y);
143 }
144
145
146 public static Vector2f operator -(Vector2f uo)
147 {
148 return uo.Negate();
149 }
150
151 public static Vector2f operator +(Vector2f lhs, Vector2f rhs)
152 {
153 return lhs.Add(rhs);
154 }
155
156 public static Vector2f operator -(Vector2f lhs, Vector2f rhs)
157 {
158 return lhs.Subtract(rhs);
159 }
160
161 public static Vector2f operator *(Vector2f lhs, Vector2f rhs)
162 {
163 return lhs.Multiply(rhs);
164 }
165
166 public static Vector2f operator *(Vector2f lhs, float rhs)
167 {
168 return lhs.Multiply(rhs);
169 }
170 public static Vector2f operator *(float lhs, Vector2f rhs)
171 {
172 return rhs.Multiply(lhs);
173 }
174
175 public static Vector2f operator /(Vector2f lhs, Vector2f rhs)
176 {
177 return lhs.Divide(rhs);
178 }
179
180 public static Vector2f operator /(Vector2f lhs, float rhs)
181 {
182 return lhs.Divide(rhs);
183 }
184
185 } // struct Vector2f
186
187 public struct Vector2d
188 {
189
190 public double x;
191 public double y;
192
193
194 public Vector2d(double _x, double _y)
195 {
196 x = _x; y = _y;
197 }
198
199 public Vector2d(Vector2d cpy)
200 {
201 x = cpy.x; y = cpy.y;
202 }
203
204
205 public Vector2d Negate()
206 {
207 return new Vector2d(-x, -y);
208 }
209
210 public Vector2d Add(Vector2d rhs)
211 {
212 return new Vector2d(x + rhs.x, y + rhs.y);
213 }
214
215 public Vector2d Subtract(Vector2d rhs)
216 {
217 return new Vector2d(x - rhs.x, y - rhs.y);
218 }
219
220 public Vector2d Multiply(Vector2d rhs)
221 {
222 return new Vector2d(x * rhs.x, y * rhs.y);
223 }
224
225 public Vector2d Multiply(double s)
226 {
227 return new Vector2d(x * s, y * s);
228 }
229
230 public Vector2d Divide(Vector2d rhs)
231 {
232 return new Vector2d(x / rhs.x, y / rhs.y);
233 }
234
235 public Vector2d Divide(double s)
236 {
237 return new Vector2d(x / s, y / s);
238 }
239
240 public double Dot(Vector2d rhs)
241 {
242 return (x * rhs.x + y * rhs.y);
243 }
244
245 public void Normalize()
246 {
247 double len = Length;
248 if (len != 0.0)
249 {
250 x /= len; y /= len;
251 }
252 }
253
254 public Vector2d Normalized
255 {
256 get
257 {
258 Vector2d normed = new Vector2d(this);
259 normed.Normalize();
260 return normed;
261 }
262 }
263
264 public double SquaredLength
265 {
266 get
267 {
268 return (x * x + y * y);
269 }
270 }
271 public double Length
272 {
273 get
274 {
275 return Math.Sqrt(SquaredLength);
276 }
277 }
278
279
280 public override string ToString()
281 {
282 return String.Format("<{0}, {1}>", x, y);
283 }
284
285
286 public static Vector2d operator -(Vector2d uo)
287 {
288 return uo.Negate();
289 }
290
291 public static Vector2d operator +(Vector2d lhs, Vector2d rhs)
292 {
293 return lhs.Add(rhs);
294 }
295
296 public static Vector2d operator -(Vector2d lhs, Vector2d rhs)
297 {
298 return lhs.Subtract(rhs);
299 }
300
301 public static Vector2d operator *(Vector2d lhs, Vector2d rhs)
302 {
303 return lhs.Multiply(rhs);
304 }
305
306 public static Vector2d operator *(Vector2d lhs, double rhs)
307 {
308 return lhs.Multiply(rhs);
309 }
310 public static Vector2d operator *(double lhs, Vector2d rhs)
311 {
312 return rhs.Multiply(lhs);
313 }
314
315 public static Vector2d operator /(Vector2d lhs, Vector2d rhs)
316 {
317 return lhs.Divide(rhs);
318 }
319
320 public static Vector2d operator /(Vector2d lhs, double rhs)
321 {
322 return lhs.Divide(rhs);
323 }
324
325 } // struct Vector2d
326
327 public struct Vector3f
328 {
329
330 public float x;
331 public float y;
332 public float z;
333
334
335 public Vector3f(float _x, float _y, float _z)
336 {
337 x = _x; y = _y; z = _z;
338 }
339
340 public Vector3f(Vector3f cpy)
341 {
342 x = cpy.x; y = cpy.y; z = cpy.z;
343 }
344
345
346 public Vector3f Negate()
347 {
348 return new Vector3f(-x, -y, -z);
349 }
350
351 public Vector3f Add(Vector3f rhs)
352 {
353 return new Vector3f(x + rhs.x, y + rhs.y, z + rhs.z);
354 }
355
356 public Vector3f Subtract(Vector3f rhs)
357 {
358 return new Vector3f(x - rhs.x, y - rhs.y, z - rhs.z);
359 }
360
361 public Vector3f Multiply(Vector3f rhs)
362 {
363 return new Vector3f(x * rhs.x, y * rhs.y, z * rhs.z);
364 }
365
366 public Vector3f Multiply(float s)
367 {
368 return new Vector3f(x * s, y * s, z * s);
369 }
370
371 public Vector3f Divide(Vector3f rhs)
372 {
373 return new Vector3f(x / rhs.x, y / rhs.y, z / rhs.z);
374 }
375
376 public Vector3f Divide(float s)
377 {
378 return new Vector3f(x / s, y / s, z / s);
379 }
380
381 public float Dot(Vector3f rhs)
382 {
383 return (x * rhs.x + y * rhs.y + z * rhs.z);
384 }
385
386 public Vector3f Cross(Vector3f rhs)
387 {
388 return new Vector3f(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x);
389 }
390
391 public void Normalize()
392 {
393 float len = Length;
394 if (len != 0.0)
395 {
396 x /= len; y /= len; z /= len;
397 }
398 }
399
400 public Vector3f Normalized
401 {
402 get
403 {
404 Vector3f normed = new Vector3f(this);
405 normed.Normalize();
406 return normed;
407 }
408 }
409
410 public float SquaredLength
411 {
412 get
413 {
414 return (x * x + y * y + z * z);
415 }
416 }
417 public float Length
418 {
419 get
420 {
421 return (float)Math.Sqrt(SquaredLength);
422 }
423 }
424
425
426 public override string ToString()
427 {
428 return String.Format("<{0}, {1}, {2}>", x, y, z);
429 }
430
431
432 public static Vector3f operator -(Vector3f uo)
433 {
434 return uo.Negate();
435 }
436
437 public static Vector3f operator +(Vector3f lhs, Vector3f rhs)
438 {
439 return lhs.Add(rhs);
440 }
441
442 public static Vector3f operator -(Vector3f lhs, Vector3f rhs)
443 {
444 return lhs.Subtract(rhs);
445 }
446
447 public static Vector3f operator *(Vector3f lhs, Vector3f rhs)
448 {
449 return lhs.Multiply(rhs);
450 }
451
452 public static Vector3f operator *(Vector3f lhs, float rhs)
453 {
454 return lhs.Multiply(rhs);
455 }
456 public static Vector3f operator *(float lhs, Vector3f rhs)
457 {
458 return rhs.Multiply(lhs);
459 }
460
461 public static Vector3f operator /(Vector3f lhs, Vector3f rhs)
462 {
463 return lhs.Divide(rhs);
464 }
465
466 public static Vector3f operator /(Vector3f lhs, float rhs)
467 {
468 return lhs.Divide(rhs);
469 }
470
471 } // struct Vector3f
472
473 public struct Vector3d
474 {
475
476 public double x;
477 public double y;
478 public double z;
479
480
481 public Vector3d(double _x, double _y, double _z)
482 {
483 x = _x; y = _y; z = _z;
484 }
485
486 public Vector3d(Vector3d cpy)
487 {
488 x = cpy.x; y = cpy.y; z = cpy.z;
489 }
490
491
492 public Vector3d Negate()
493 {
494 return new Vector3d(-x, -y, -z);
495 }
496
497 public Vector3d Add(Vector3d rhs)
498 {
499 return new Vector3d(x + rhs.x, y + rhs.y, z + rhs.z);
500 }
501
502 public Vector3d Subtract(Vector3d rhs)
503 {
504 return new Vector3d(x - rhs.x, y - rhs.y, z - rhs.z);
505 }
506
507 public Vector3d Multiply(Vector3d rhs)
508 {
509 return new Vector3d(x * rhs.x, y * rhs.y, z * rhs.z);
510 }
511
512 public Vector3d Multiply(double s)
513 {
514 return new Vector3d(x * s, y * s, z * s);
515 }
516
517 public Vector3d Divide(Vector3d rhs)
518 {
519 return new Vector3d(x / rhs.x, y / rhs.y, z / rhs.z);
520 }
521
522 public Vector3d Divide(double s)
523 {
524 return new Vector3d(x / s, y / s, z / s);
525 }
526
527 public double Dot(Vector3d rhs)
528 {
529 return (x * rhs.x + y * rhs.y + z * rhs.z);
530 }
531
532 public Vector3d Cross(Vector3d rhs)
533 {
534 return new Vector3d(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x);
535 }
536
537 public void Normalize()
538 {
539 double len = Length;
540 if (len != 0.0)
541 {
542 x /= len; y /= len; z /= len;
543 }
544 }
545
546 public Vector3d Normalized
547 {
548 get
549 {
550 Vector3d normed = new Vector3d(this);
551 normed.Normalize();
552 return normed;
553 }
554 }
555
556 public double SquaredLength
557 {
558 get
559 {
560 return (x * x + y * y + z * z);
561 }
562 }
563 public double Length
564 {
565 get
566 {
567 return Math.Sqrt(SquaredLength);
568 }
569 }
570
571
572 public override string ToString()
573 {
574 return String.Format("<{0}, {1}, {2}>", x, y, z);
575 }
576
577
578 public static Vector3d operator -(Vector3d uo)
579 {
580 return uo.Negate();
581 }
582
583 public static Vector3d operator +(Vector3d lhs, Vector3d rhs)
584 {
585 return lhs.Add(rhs);
586 }
587
588 public static Vector3d operator -(Vector3d lhs, Vector3d rhs)
589 {
590 return lhs.Subtract(rhs);
591 }
592
593 public static Vector3d operator *(Vector3d lhs, Vector3d rhs)
594 {
595 return lhs.Multiply(rhs);
596 }
597
598 public static Vector3d operator *(Vector3d lhs, double rhs)
599 {
600 return lhs.Multiply(rhs);
601 }
602 public static Vector3d operator *(double lhs, Vector3d rhs)
603 {
604 return rhs.Multiply(lhs);
605 }
606
607 public static Vector3d operator /(Vector3d lhs, Vector3d rhs)
608 {
609 return lhs.Divide(rhs);
610 }
611
612 public static Vector3d operator /(Vector3d lhs, double rhs)
613 {
614 return lhs.Divide(rhs);
615 }
616
617 } // struct Vector3d
618
619 public struct Quaternion
620 {
621
622 public float w;
623 public float x;
624 public float y;
625 public float z;
626
627
628 public Quaternion(float _w, float _x, float _y, float _z)
629 {
630 w = _w; x = _x; y = _y; z = _z;
631 }
632
633 public Quaternion(Quaternion cpy)
634 {
635 w = cpy.w; x = cpy.x; y = cpy.y; z = cpy.z;
636 }
637
638 public static readonly Quaternion Identity = new Quaternion((float)1.0, (float)0.0, (float)0.0, (float)0.0);
639
640 public static Quaternion FromAxisAngle(Vector3f axis, float rads)
641 {
642 float halfAngle = rads * 0.5f;
643 float sinHalf = (float)Math.Sin(halfAngle);
644 float w = (float)Math.Cos(halfAngle);
645 float x = sinHalf * axis.x;
646 float y = sinHalf * axis.y;
647 float z = sinHalf * axis.z;
648 return new Quaternion(w, x, y, z);
649 }
650
651 public static Quaternion FromAxisAngle(Vector3d axis, float rads)
652 {
653 float halfAngle = rads * 0.5f;
654 float sinHalf = (float)Math.Sin(halfAngle);
655 float w = (float)Math.Cos(halfAngle);
656 float x = (float)(sinHalf * axis.x);
657 float y = (float)(sinHalf * axis.y);
658 float z = (float)(sinHalf * axis.z);
659 return new Quaternion(w, x, y, z);
660 }
661
662
663 public Quaternion Add(Quaternion rhs)
664 {
665 return new Quaternion(w + rhs.w, x + rhs.x, y + rhs.y, z + rhs.z);
666 }
667
668 public Quaternion Subtract(Quaternion rhs)
669 {
670 return new Quaternion(w - rhs.w, x - rhs.x, y - rhs.y, z - rhs.z);
671 }
672
673 public Quaternion Multiply(Quaternion rhs)
674 {
675 return new Quaternion(
676 w * rhs.w - x * rhs.x - y * rhs.y - z * rhs.z,
677 w * rhs.x + x * rhs.w + y * rhs.z - z * rhs.y,
678 w * rhs.y + y * rhs.w + z * rhs.x - x * rhs.z,
679 w * rhs.z + z * rhs.w + x * rhs.y - y * rhs.x
680 );
681 }
682
683 public Vector3f Multiply(Vector3f rhs)
684 {
685 Vector3f qvec = new Vector3f(x, y, z);
686 Vector3f uv = qvec.Cross(rhs);
687 Vector3f uuv = qvec.Cross(uv);
688 uv *= 2.0f * w;
689 uuv *= 2.0f;
690
691 return rhs + uv + uuv;
692 }
693
694 public Vector3d Multiply(Vector3d rhs)
695 {
696 Vector3d qvec = new Vector3d(x, y, z);
697 Vector3d uv = qvec.Cross(rhs);
698 Vector3d uuv = qvec.Cross(uv);
699 uv *= 2.0f * w;
700 uuv *= 2.0f;
701
702 return rhs + uv + uuv;
703 }
704
705 public Quaternion Multiply(float rhs)
706 {
707 return new Quaternion(w * rhs, x * rhs, y * rhs, z * rhs);
708 }
709
710 public Quaternion Negate()
711 {
712 return new Quaternion(-w, -x, -y, -z);
713 }
714
715 public float Dot(Quaternion rhs)
716 {
717 return (w * rhs.w + x * rhs.x + y * rhs.y + z * rhs.z);
718 }
719
720 public float Norm
721 {
722 get
723 {
724 return (float)Math.Sqrt(w * w + x * x + y * y + z * z);
725 }
726 }
727
728 public float SquareNorm
729 {
730 get
731 {
732 return (w * w + x * x + y * y + z * z);
733 }
734 }
735
736 public void Normalize()
737 {
738 float len = SquareNorm;
739 if (len == 0.0) return;
740 float factor = 1.0f / (float)Math.Sqrt(len);
741 this *= factor;
742 }
743
744 public Quaternion Normalized
745 {
746 get
747 {
748 Quaternion q = new Quaternion(this);
749 q.Normalize();
750 return q;
751 }
752 }
753
754 public Quaternion Inverse
755 {
756 get
757 {
758 float norm = SquareNorm;
759 if (norm > 0.0)
760 {
761 double invnorm = 1.0 / norm;
762 return new Quaternion((float)(w * invnorm), (float)(-x * invnorm), (float)(-y * invnorm), (float)(-z * invnorm));
763 }
764 else
765 return new Quaternion((float)0.0, 0.0f, 0.0f, 0.0f);
766 }
767 }
768
769
770 public override string ToString()
771 {
772 return String.Format("<{0}, {1}, {2}, {3}>", w, x, y, z);
773 }
774
775
776
777 public static Quaternion operator -(Quaternion uo)
778 {
779 return uo.Negate();
780 }
781
782 public static Quaternion operator +(Quaternion lhs, Quaternion rhs)
783 {
784 return lhs.Add(rhs);
785 }
786
787 public static Quaternion operator -(Quaternion lhs, Quaternion rhs)
788 {
789 return lhs.Subtract(rhs);
790 }
791
792 public static Vector3f operator *(Quaternion lhs, Vector3f rhs)
793 {
794 return lhs.Multiply(rhs);
795 }
796
797 public static Vector3d operator *(Quaternion lhs, Vector3d rhs)
798 {
799 return lhs.Multiply(rhs);
800 }
801
802 public static Quaternion operator *(Quaternion lhs, Quaternion rhs)
803 {
804 return lhs.Multiply(rhs);
805 }
806
807 public static Quaternion operator *(Quaternion lhs, float rhs)
808 {
809 return lhs.Multiply(rhs);
810 }
811
812 public static Quaternion operator *(float lhs, Quaternion rhs)
813 {
814 return rhs.Multiply(lhs);
815 }
816
817 } // struct Quaternion
818
819
820 public struct Vector4f
821 {
822
823 public float x;
824 public float y;
825 public float z;
826 public float w;
827
828
829 public Vector4f(float _x, float _y, float _z, float _w)
830 {
831 x = _x; y = _y; z = _z; w = _w;
832 }
833
834 public Vector4f(Vector4f cpy)
835 {
836 x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w;
837 }
838
839
840 public Vector4f Negate()
841 {
842 return new Vector4f(-x, -y, -z, -w);
843 }
844
845 public Vector4f Add(Vector4f rhs)
846 {
847 return new Vector4f(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w);
848 }
849
850 public Vector4f Subtract(Vector4f rhs)
851 {
852 return new Vector4f(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w);
853 }
854
855 public Vector4f Multiply(Vector4f rhs)
856 {
857 return new Vector4f(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w);
858 }
859
860 public Vector4f Multiply(float s)
861 {
862 return new Vector4f(x * s, y * s, z * s, w * s);
863 }
864
865 public Vector4f Divide(Vector4f rhs)
866 {
867 return new Vector4f(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w);
868 }
869
870 public Vector4f Divide(float s)
871 {
872 return new Vector4f(x / s, y / s, z / s, w / s);
873 }
874
875 public float Dot(Vector4f rhs)
876 {
877 return (x * rhs.x + y * rhs.y + z * rhs.z + w * rhs.w);
878 }
879
880 public void Normalize()
881 {
882 float len = Length;
883 if (len != 0.0)
884 {
885 x /= len; y /= len; z /= len; w /= len;
886 }
887 }
888
889 public Vector4f Normalized
890 {
891 get
892 {
893 Vector4f normed = new Vector4f(this);
894 normed.Normalize();
895 return normed;
896 }
897 }
898
899 public float SquaredLength
900 {
901 get
902 {
903 return (x * x + y * y + z * z + w * w);
904 }
905 }
906 public float Length
907 {
908 get
909 {
910 return (float)Math.Sqrt(SquaredLength);
911 }
912 }
913
914
915 public override string ToString()
916 {
917 return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w);
918 }
919
920
921 public static Vector4f operator -(Vector4f uo)
922 {
923 return uo.Negate();
924 }
925
926 public static Vector4f operator +(Vector4f lhs, Vector4f rhs)
927 {
928 return lhs.Add(rhs);
929 }
930
931 public static Vector4f operator -(Vector4f lhs, Vector4f rhs)
932 {
933 return lhs.Subtract(rhs);
934 }
935
936 public static Vector4f operator *(Vector4f lhs, Vector4f rhs)
937 {
938 return lhs.Multiply(rhs);
939 }
940
941 public static Vector4f operator *(Vector4f lhs, float rhs)
942 {
943 return lhs.Multiply(rhs);
944 }
945 public static Vector4f operator *(float lhs, Vector4f rhs)
946 {
947 return rhs.Multiply(lhs);
948 }
949
950 public static Vector4f operator /(Vector4f lhs, Vector4f rhs)
951 {
952 return lhs.Divide(rhs);
953 }
954
955 public static Vector4f operator /(Vector4f lhs, float rhs)
956 {
957 return lhs.Divide(rhs);
958 }
959
960 } // struct Vector4f
961
962
963
964 public struct Vector4d
965 {
966
967 public double x;
968 public double y;
969 public double z;
970 public double w;
971
972
973 public Vector4d(double _x, double _y, double _z, double _w)
974 {
975 x = _x; y = _y; z = _z; w = _w;
976 }
977
978 public Vector4d(Vector4d cpy)
979 {
980 x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w;
981 }
982
983
984 public Vector4d Negate()
985 {
986 return new Vector4d(-x, -y, -z, -w);
987 }
988
989 public Vector4d Add(Vector4d rhs)
990 {
991 return new Vector4d(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w);
992 }
993
994 public Vector4d Subtract(Vector4d rhs)
995 {
996 return new Vector4d(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w);
997 }
998
999 public Vector4d Multiply(Vector4d rhs)
1000 {
1001 return new Vector4d(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w);
1002 }
1003
1004 public Vector4d Multiply(double s)
1005 {
1006 return new Vector4d(x * s, y * s, z * s, w * s);
1007 }
1008
1009 public Vector4d Divide(Vector4d rhs)
1010 {
1011 return new Vector4d(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w);
1012 }
1013
1014 public Vector4d Divide(double s)
1015 {
1016 return new Vector4d(x / s, y / s, z / s, w / s);
1017 }
1018
1019 public double Dot(Vector4d rhs)
1020 {
1021 return (x * rhs.x + y * rhs.y + z * rhs.z + w * rhs.w);
1022 }
1023
1024 public void Normalize()
1025 {
1026 double len = Length;
1027 if (len != 0.0)
1028 {
1029 x /= len; y /= len; z /= len; w /= len;
1030 }
1031 }
1032
1033 public Vector4d Normalized
1034 {
1035 get
1036 {
1037 Vector4d normed = new Vector4d(this);
1038 normed.Normalize();
1039 return normed;
1040 }
1041 }
1042
1043 public double SquaredLength
1044 {
1045 get
1046 {
1047 return (x * x + y * y + z * z + w * w);
1048 }
1049 }
1050 public double Length
1051 {
1052 get
1053 {
1054 return Math.Sqrt(SquaredLength);
1055 }
1056 }
1057
1058
1059 public override string ToString()
1060 {
1061 return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w);
1062 }
1063
1064
1065 public static Vector4d operator -(Vector4d uo)
1066 {
1067 return uo.Negate();
1068 }
1069
1070 public static Vector4d operator +(Vector4d lhs, Vector4d rhs)
1071 {
1072 return lhs.Add(rhs);
1073 }
1074
1075 public static Vector4d operator -(Vector4d lhs, Vector4d rhs)
1076 {
1077 return lhs.Subtract(rhs);
1078 }
1079
1080 public static Vector4d operator *(Vector4d lhs, Vector4d rhs)
1081 {
1082 return lhs.Multiply(rhs);
1083 }
1084
1085 public static Vector4d operator *(Vector4d lhs, double rhs)
1086 {
1087 return lhs.Multiply(rhs);
1088 }
1089 public static Vector4d operator *(double lhs, Vector4d rhs)
1090 {
1091 return rhs.Multiply(lhs);
1092 }
1093
1094 public static Vector4d operator /(Vector4d lhs, Vector4d rhs)
1095 {
1096 return lhs.Divide(rhs);
1097 }
1098
1099 public static Vector4d operator /(Vector4d lhs, double rhs)
1100 {
1101 return lhs.Divide(rhs);
1102 }
1103
1104 } // struct Vector4d
1105
1106
1107
1108 public struct BoundingBox3f3f
1109 {
1110 Vector3f mMin;
1111 Vector3f mDiag;
1112 public BoundingBox3f3f(float minx, float miny, float minz, float diagx, float diagy, float diagz)
1113 {
1114 mMin.x = minx;
1115 mMin.y = miny;
1116 mMin.z = minz;
1117
1118 mDiag.x = diagx;
1119 mDiag.y = diagy;
1120 mDiag.z = diagz;
1121 }
1122 public BoundingBox3f3f(Vector3f min, Vector3f max)
1123 {
1124 mMin = min;
1125 mDiag = (max - min);
1126 }
1127 public BoundingBox3f3f(BoundingBox3f3f cpy, Vector3f scale)
1128 {
1129 mMin.x = (float)(cpy.mMin.x * scale.x);
1130 mMin.y = (float)(cpy.mMin.y * scale.y);
1131 mMin.z = (float)(cpy.mMin.z * scale.z);
1132
1133 mDiag.x = (float)(cpy.mDiag.x * scale.x);
1134 mDiag.y = (float)(cpy.mDiag.y * scale.y);
1135 mDiag.z = (float)(cpy.mDiag.z * scale.z);
1136 }
1137 public Vector3f Min
1138 {
1139 get
1140 {
1141 return new Vector3f(mMin.x, mMin.y, mMin.z);
1142 }
1143 }
1144 public Vector3f Max
1145 {
1146 get
1147 {
1148 return new Vector3f(mMin.x + mDiag.x, mMin.y + mDiag.y, mMin.z + mDiag.z);
1149 }
1150 }
1151
1152 public Vector3f Diag
1153 {
1154 get
1155 {
1156 return new Vector3f(mDiag.x, mDiag.y, mDiag.z);
1157 }
1158 }
1159
1160
1161 public override string ToString()
1162 {
1163 return "[" + this.Min.ToString() + " - " + this.Max.ToString() + "]";
1164 }
1165 public BoundingBox3f3f Merge(BoundingBox3f3f other)
1166 {
1167 Vector3f thisMax = Max;
1168 Vector3f otherMax = other.Max;
1169 bool xless = other.mMin.x > mMin.x;
1170 bool yless = other.mMin.y > mMin.y;
1171 bool zless = other.mMin.z > mMin.z;
1172
1173 bool xmore = otherMax.x < thisMax.x;
1174 bool ymore = otherMax.y < thisMax.y;
1175 bool zmore = otherMax.z < thisMax.z;
1176 return new BoundingBox3f3f(xless ? mMin.x : other.mMin.x,
1177 yless ? mMin.y : other.mMin.y,
1178 zless ? mMin.z : other.mMin.z,
1179 xmore ? (xless ? mDiag.x : otherMax.x - mMin.x) : (xless ? thisMax.x - other.mMin.x : other.mDiag.x),
1180 ymore ? (yless ? mDiag.y : otherMax.y - mMin.y) : (yless ? thisMax.y - other.mMin.y : other.mDiag.y),
1181 zmore ? (zless ? mDiag.z : otherMax.z - mMin.z) : (zless ? thisMax.z - other.mMin.z : other.mDiag.z));
1182 }
1183
1184 } // struct BoundingBox
1185
1186 public struct BoundingBox3d3f
1187 {
1188 Vector3d mMin;
1189 Vector3f mDiag;
1190 public BoundingBox3d3f(double minx, double miny, double minz, float diagx, float diagy, float diagz)
1191 {
1192 mMin.x = minx;
1193 mMin.y = miny;
1194 mMin.z = minz;
1195
1196 mDiag.x = diagx;
1197 mDiag.y = diagy;
1198 mDiag.z = diagz;
1199 }
1200 public BoundingBox3d3f(Vector3d min, Vector3f max)
1201 {
1202 mMin = min;
1203
1204 mDiag = new Vector3f((float)(max.x - min.x),
1205 (float)(max.y - min.y),
1206 (float)(max.z - min.z));
1207 }
1208 public BoundingBox3d3f(BoundingBox3d3f cpy, Vector3d scale)
1209 {
1210 mMin.x = (double)(cpy.mMin.x * scale.x);
1211 mMin.y = (double)(cpy.mMin.y * scale.y);
1212 mMin.z = (double)(cpy.mMin.z * scale.z);
1213
1214 mDiag.x = (float)(cpy.mDiag.x * scale.x);
1215 mDiag.y = (float)(cpy.mDiag.y * scale.y);
1216 mDiag.z = (float)(cpy.mDiag.z * scale.z);
1217 }
1218 public Vector3d Min
1219 {
1220 get
1221 {
1222 return new Vector3d(mMin.x, mMin.y, mMin.z);
1223 }
1224 }
1225 public Vector3d Max
1226 {
1227 get
1228 {
1229 return new Vector3d(mMin.x + mDiag.x, mMin.y + mDiag.y, mMin.z + mDiag.z);
1230 }
1231 }
1232
1233 public Vector3d Diag
1234 {
1235 get
1236 {
1237 return new Vector3d(mDiag.x, mDiag.y, mDiag.z);
1238 }
1239 }
1240
1241
1242 public override string ToString()
1243 {
1244 return "[" + this.Min.ToString() + " - " + this.Max.ToString() + "]";
1245 }
1246 public BoundingBox3d3f Merge(BoundingBox3d3f other)
1247 {
1248 Vector3d thisMax = Max;
1249 Vector3d otherMax = other.Max;
1250 bool xless = other.mMin.x > mMin.x;
1251 bool yless = other.mMin.y > mMin.y;
1252 bool zless = other.mMin.z > mMin.z;
1253
1254 bool xmore = otherMax.x < thisMax.x;
1255 bool ymore = otherMax.y < thisMax.y;
1256 bool zmore = otherMax.z < thisMax.z;
1257 return new BoundingBox3d3f(xless ? mMin.x : other.mMin.x,
1258 yless ? mMin.y : other.mMin.y,
1259 zless ? mMin.z : other.mMin.z,
1260 (float)(xmore ? (xless ? mDiag.x : otherMax.x - mMin.x) : (xless ? thisMax.x - other.mMin.x : other.mDiag.x)),
1261 (float)(ymore ? (yless ? mDiag.y : otherMax.y - mMin.y) : (yless ? thisMax.y - other.mMin.y : other.mDiag.y)),
1262 (float)(zmore ? (zless ? mDiag.z : otherMax.z - mMin.z) : (zless ? thisMax.z - other.mMin.z : other.mDiag.z)));
1263 }
1264
1265 } // struct BoundingBox
1266
1267
1268
1269
1270 public struct BoundingSphere3f
1271 {
1272 Vector3f mCenter;
1273 float mRadius;
1274 public BoundingSphere3f(float x, float y, float z, float r)
1275 {
1276 mCenter = new Vector3f(x, y, z);
1277 mRadius = r;
1278 }
1279 public BoundingSphere3f(Vector3f center, float radius)
1280 {
1281 mCenter = center;
1282 mRadius = radius;
1283 }
1284 public BoundingSphere3f(BoundingSphere3f cpy, float scale)
1285 {
1286 mCenter = cpy.mCenter;
1287 mRadius = cpy.mRadius * scale;
1288 }
1289 public Vector3f Center
1290 {
1291 get
1292 {
1293 return new Vector3f(mCenter.x, mCenter.y, mCenter.z);
1294 }
1295 }
1296 public float Radius
1297 {
1298 get
1299 {
1300 return mRadius;
1301 }
1302 }
1303
1304 public override string ToString()
1305 {
1306 return "[" + this.Center.ToString() + " : " + this.Radius.ToString() + "]";
1307 }
1308 } // struct BoundingSphere3f
1309
1310
1311
1312 public struct BoundingSphere3d
1313 {
1314 Vector3d mCenter;
1315 float mRadius;
1316 public BoundingSphere3d(double x, double y, double z, float r)
1317 {
1318 mCenter.x = x;
1319 mCenter.y = y;
1320 mCenter.z = z;
1321 mRadius = r;
1322 }
1323 public BoundingSphere3d(Vector3d center, float radius)
1324 {
1325 mCenter = center;
1326 mRadius = radius;
1327 }
1328 public BoundingSphere3d(BoundingSphere3d cpy, float scale)
1329 {
1330 mCenter = cpy.mCenter;
1331 mRadius = cpy.mRadius * scale;
1332 }
1333 public Vector3d Center
1334 {
1335 get
1336 {
1337 return new Vector3d(mCenter.x, mCenter.y, mCenter.z);
1338 }
1339 }
1340 public float Radius
1341 {
1342 get
1343 {
1344 return mRadius;
1345 }
1346 }
1347
1348 public override string ToString()
1349 {
1350 return "[" + this.Center.ToString() + " : " + this.Radius.ToString() + "]";
1351 }
1352 } // struct BoundingSphere3f
1353
1354 public struct UUID
1355 {
1356 ulong mLowOrderBytes;
1357 ulong mHighOrderBytes;
1358
1359
1360 static ulong SetUUIDlow(Google.ProtocolBuffers.ByteString data, int offset)
1361 {
1362 ulong LowOrderBytes = 0;
1363 int shiftVal = 0;
1364 for (int i = 0; i < 8; ++i)
1365 {
1366 ulong temp = data[i];
1367 LowOrderBytes |= (temp << shiftVal);
1368 shiftVal += 8;
1369 }
1370 return LowOrderBytes;
1371 }
1372 static ulong SetUUIDhigh(Google.ProtocolBuffers.ByteString data)
1373 {
1374 return SetUUIDlow(data, 8);
1375 }
1376 static ulong SetUUIDlow(byte[] data, int offset)
1377 {
1378 ulong LowOrderBytes = 0;
1379 int shiftVal = 0;
1380 for (int i = 0; i < 8; ++i)
1381 {
1382 ulong temp = data[i];
1383 LowOrderBytes |= (temp << shiftVal);
1384 shiftVal += 8;
1385 }
1386 return LowOrderBytes;
1387 }
1388 static ulong SetUUIDhigh(byte[] data)
1389 {
1390 return SetUUIDlow(data, 8);
1391 }
1392 public bool SetUUID(byte[] data)
1393 {
1394 if (data.Length == 16)
1395 {
1396 mLowOrderBytes = 0;
1397 mHighOrderBytes = 0;
1398 mLowOrderBytes = SetUUIDlow(data, 0);
1399 mHighOrderBytes = SetUUIDlow(data, 8);
1400 return true;
1401 }
1402 else
1403 {
1404 return false;
1405 }
1406 }
1407 public byte[] GetUUID()
1408 {
1409 byte[] data = new byte[16];
1410 int shiftVal = 0;
1411 for (int i = 0; i < 8; ++i)
1412 {
1413 ulong temp = 0xff;
1414 temp = (mLowOrderBytes & (temp << shiftVal));
1415 temp = (temp >> shiftVal);
1416 data[i] = (byte)temp;
1417 shiftVal += 8;
1418 }
1419 shiftVal = 0;
1420 for (int i = 8; i < 16; ++i)
1421 {
1422 ulong temp = 0xff;
1423 temp = (mHighOrderBytes & (temp << shiftVal));
1424 temp = (temp >> shiftVal);
1425 data[i] = (byte)temp;
1426 shiftVal += 8;
1427 }
1428 return data;
1429 }
1430
1431 public static UUID Empty = new UUID(new byte[16]);
1432 public UUID(byte[] data)
1433 {
1434 if (data.Length != 16)
1435 {
1436 throw new System.ArgumentException("UUIDs must be provided 16 bytes");
1437 }
1438 mLowOrderBytes = SetUUIDlow(data, 0);
1439 mHighOrderBytes = SetUUIDhigh(data);
1440 }
1441 public UUID(Google.ProtocolBuffers.ByteString data)
1442 {
1443 if (data.Length != 16)
1444 {
1445 throw new System.ArgumentException("UUIDs must be provided 16 bytes");
1446 }
1447 mLowOrderBytes = SetUUIDlow(data, 0);
1448 mHighOrderBytes = SetUUIDhigh(data);
1449 }
1450
1451 }
1452
1453
1454 public struct SHA256
1455 {
1456 ulong mLowOrderBytes;
1457 ulong mLowMediumOrderBytes;
1458 ulong mMediumHighOrderBytes;
1459 ulong mHighOrderBytes;
1460
1461
1462 static ulong SetLMH(Google.ProtocolBuffers.ByteString data, int offset)
1463 {
1464 ulong LowOrderBytes = 0;
1465 int shiftVal = 0;
1466 for (int i = 0; i < 8; ++i)
1467 {
1468 ulong temp = data[i];
1469 LowOrderBytes |= (temp << shiftVal);
1470 shiftVal += 8;
1471 }
1472 return LowOrderBytes;
1473 }
1474 static ulong SetLow(Google.ProtocolBuffers.ByteString data)
1475 {
1476 return SetLMH(data, 0);
1477 }
1478 static ulong SetLowMedium(Google.ProtocolBuffers.ByteString data)
1479 {
1480 return SetLMH(data, 8);
1481 }
1482 static ulong SetMediumHigh(Google.ProtocolBuffers.ByteString data)
1483 {
1484 return SetLMH(data, 16);
1485 }
1486 static ulong SetHigh(Google.ProtocolBuffers.ByteString data)
1487 {
1488 return SetLMH(data, 24);
1489 }
1490 static ulong SetLMH(byte[] data, int offset)
1491 {
1492 ulong LowOrderBytes = 0;
1493 int shiftVal = 0;
1494 for (int i = 0; i < 8; ++i)
1495 {
1496 ulong temp = data[i];
1497 LowOrderBytes |= (temp << shiftVal);
1498 shiftVal += 8;
1499 }
1500 return LowOrderBytes;
1501 }
1502 static ulong SetLow(byte[] data)
1503 {
1504 return SetLMH(data, 0);
1505 }
1506 static ulong SetLowMedium(byte[] data)
1507 {
1508 return SetLMH(data, 8);
1509 }
1510 static ulong SetMediumHigh(byte[] data)
1511 {
1512 return SetLMH(data, 16);
1513 }
1514 static ulong SetHigh(byte[] data)
1515 {
1516 return SetLMH(data, 24);
1517 }
1518 public bool SetSHA256(byte[] data)
1519 {
1520 if (data.Length == 32)
1521 {
1522 mLowOrderBytes = SetLow(data);
1523 mLowMediumOrderBytes = SetLowMedium(data);
1524 mMediumHighOrderBytes = SetMediumHigh(data);
1525 mHighOrderBytes = SetHigh(data);
1526 return true;
1527 }
1528 else
1529 {
1530 return false;
1531 }
1532 }
1533 public byte[] GetBinaryData()
1534 {
1535 byte[] data = new byte[32];
1536 int shiftVal = 0;
1537 for (int i = 0; i < 8; ++i)
1538 {
1539 ulong temp = 0xff;
1540 temp = (mLowOrderBytes & (temp << shiftVal));
1541 temp = (temp >> shiftVal);
1542 data[i] = (byte)temp;
1543 shiftVal += 8;
1544 }
1545 shiftVal = 0;
1546 for (int i = 8; i < 16; ++i)
1547 {
1548 ulong temp = 0xff;
1549 temp = (mLowMediumOrderBytes & (temp << shiftVal));
1550 temp = (temp >> shiftVal);
1551 data[i] = (byte)temp;
1552 shiftVal += 8;
1553 }
1554 shiftVal = 0;
1555 for (int i = 16; i < 24; ++i)
1556 {
1557 ulong temp = 0xff;
1558 temp = (mMediumHighOrderBytes & (temp << shiftVal));
1559 temp = (temp >> shiftVal);
1560 data[i] = (byte)temp;
1561 shiftVal += 8;
1562 }
1563 shiftVal = 0;
1564 for (int i = 24; i < 32; ++i)
1565 {
1566 ulong temp = 0xff;
1567 temp = (mHighOrderBytes & (temp << shiftVal));
1568 temp = (temp >> shiftVal);
1569 data[i] = (byte)temp;
1570 shiftVal += 8;
1571 }
1572 return data;
1573 }
1574
1575 public static SHA256 Empty = new SHA256(new byte[32]);
1576 public SHA256(byte[] data)
1577 {
1578 if (data.Length != 32)
1579 {
1580 throw new System.ArgumentException("SHA256s must be provided 32 bytes");
1581 }
1582 mLowOrderBytes = SetLow(data);
1583 mLowMediumOrderBytes = SetLowMedium(data);
1584 mMediumHighOrderBytes = SetMediumHigh(data);
1585 mHighOrderBytes = SetHigh(data);
1586 }
1587 public SHA256(Google.ProtocolBuffers.ByteString data)
1588 {
1589 if (data.Length != 32)
1590 {
1591 throw new System.ArgumentException("SHA256s must be provided 32 bytes");
1592 }
1593 mLowOrderBytes = SetLow(data);
1594 mLowMediumOrderBytes = SetLowMedium(data);
1595 mMediumHighOrderBytes = SetMediumHigh(data);
1596 mHighOrderBytes = SetHigh(data);
1597 }
1598
1599 }
1600
1601
1602
1603
1604 public struct Time
1605 {
1606 ulong usec;
1607 public Time(ulong usec_since_epoch)
1608 {
1609 usec = usec_since_epoch;
1610 }
1611 public ulong toMicro()
1612 {
1613 return usec;
1614 }
1615 }
1616 public class Duration
1617 {
1618 long usec;
1619 public Duration(long time_since)
1620 {
1621 usec = time_since;
1622 }
1623 public long toMicro()
1624 {
1625 return usec;
1626 }
1627 }
1628
1629 class _PBJ
1630 {
1631
1632 public static bool ValidateBool(bool d)
1633 {
1634 return true;
1635 }
1636 public static bool ValidateDouble(double d)
1637 {
1638 return true;
1639 }
1640 public static bool ValidateFloat(float d)
1641 {
1642 return true;
1643 }
1644 public static bool ValidateUint64(ulong d)
1645 {
1646 return true;
1647 }
1648 public static bool ValidateUint32(uint d)
1649 {
1650 return true;
1651 }
1652 public static bool ValidateUint16(ushort d)
1653 {
1654 return true;
1655 }
1656 public static bool ValidateUint8(byte d)
1657 {
1658 return true;
1659 }
1660 public static bool ValidateInt64(long d)
1661 {
1662 return true;
1663 }
1664 public static bool ValidateInt32(int d)
1665 {
1666 return true;
1667 }
1668 public static bool ValidateInt16(short d)
1669 {
1670 return true;
1671 }
1672 public static bool ValidateInt8(sbyte d)
1673 {
1674 return true;
1675 }
1676 public static bool ValidateString<S>(S input)
1677 {
1678 return true;
1679 }
1680 public static bool ValidateBytes<B>(B input)
1681 {
1682 return true;
1683 }
1684 public static bool ValidateUuid(Google.ProtocolBuffers.ByteString input)
1685 {
1686 return input.Length == 16;
1687 }
1688 public static bool ValidateSha256(Google.ProtocolBuffers.ByteString input)
1689 {
1690 return input.Length == 32;
1691 }
1692 public static bool ValidateAngle(float input)
1693 {
1694 return input >= 0 && input <= 3.1415926536 * 2.0;
1695 }
1696 public static bool ValidateTime(ulong input)
1697 {
1698 return true;
1699 }
1700 public static bool ValidateDuration(long input)
1701 {
1702 return true;
1703 }
1704 public static bool ValidateFlags(ulong input, ulong verification)
1705 {
1706 return (input & verification) == input;
1707 }
1708
1709
1710
1711
1712 public static bool CastBool(bool d)
1713 {
1714 return d;
1715 }
1716 public static double CastDouble(double d)
1717 {
1718 return d;
1719 }
1720 public static float CastFloat(float d)
1721 {
1722 return d;
1723 }
1724 public static ulong CastUint64(ulong d)
1725 {
1726 return d;
1727 }
1728 public static uint CastUint32(uint d)
1729 {
1730 return d;
1731 }
1732 public static ushort CastUint16(ushort d)
1733 {
1734 return d;
1735 }
1736 public static byte CastUint8(byte d)
1737 {
1738 return d;
1739 }
1740 public static long CastInt64(long d)
1741 {
1742 return d;
1743 }
1744 public static int CastInt32(int d)
1745 {
1746 return d;
1747 }
1748 public static short CastInt16(short d)
1749 {
1750 return d;
1751 }
1752 public static sbyte CastInt8(sbyte d)
1753 {
1754 return d;
1755 }
1756 public static S CastString<S>(S input)
1757 {
1758 return input;
1759 }
1760 public static B CastBytes<B>(B input)
1761 {
1762 return input;
1763 }
1764
1765
1766
1767 public static bool CastBool()
1768 {
1769 return false;
1770 }
1771 public static double CastDouble()
1772 {
1773 return 0;
1774 }
1775 public static float CastFloat()
1776 {
1777 return 0;
1778 }
1779 public static ulong CastUint64()
1780 {
1781 return 0;
1782 }
1783 public static uint CastUint32()
1784 {
1785 return 0;
1786 }
1787 public static ushort CastUint16()
1788 {
1789 return 0;
1790 }
1791 public static byte CastUint8()
1792 {
1793 return 0;
1794 }
1795 public static long CastInt64()
1796 {
1797 return 0;
1798 }
1799 public static int CastInt32()
1800 {
1801 return 0;
1802 }
1803 public static short CastInt16()
1804 {
1805 return 0;
1806 }
1807 public static sbyte CastInt8()
1808 {
1809 return 0;
1810 }
1811 public static string CastString()
1812 {
1813 return "";
1814 }
1815 public static Google.ProtocolBuffers.ByteString CastBytes()
1816 {
1817 return Google.ProtocolBuffers.ByteString.Empty;
1818 }
1819
1820
1821 public static ulong CastFlags(ulong data, ulong allFlagsOn)
1822 {
1823 return allFlagsOn & data;
1824 }
1825 public static ulong CastFlags(ulong allFlagsOn)
1826 {
1827 return 0;
1828 }
1829
1830 public static Vector3f CastNormal(float x, float y)
1831 {
1832 float neg = (x > 1.5f || y > 1.5f) ? -1.0f : 1.0f;
1833 if (x > 1.5)
1834 x -= 3;
1835 if (y > 1.5)
1836 y -= 3;
1837 return new Vector3f(x, y, neg - neg * (float)Math.Sqrt(x * x + y * y));
1838 }
1839 public static Vector3f CastNormal()
1840 {
1841 return new Vector3f(0, 1, 0);
1842 }
1843
1844
1845 public static Vector2f CastVector2f(float x, float y)
1846 {
1847 return new Vector2f(x, y);
1848 }
1849 public static Vector2f CastVector2f()
1850 {
1851 return new Vector2f(0, 0);
1852 }
1853
1854 public static Vector3f CastVector3f(float x, float y, float z)
1855 {
1856 return new Vector3f(x, y, z);
1857 }
1858 public static Vector3f CastVector3f()
1859 {
1860 return new Vector3f(0, 0, 0);
1861 }
1862
1863 public static Vector4f CastVector4f(float x, float y, float z, float w)
1864 {
1865 return new Vector4f(x, y, z, w);
1866 }
1867 public static Vector4f CastVector4f()
1868 {
1869 return new Vector4f(0, 0, 0, 0);
1870 }
1871 public static Vector2d CastVector2d(double x, double y)
1872 {
1873 return new Vector2d(x, y);
1874 }
1875 public static Vector2d CastVector2d()
1876 {
1877 return new Vector2d(0, 0);
1878 }
1879
1880 public static Vector3d CastVector3d(double x, double y, double z)
1881 {
1882 return new Vector3d(x, y, z);
1883 }
1884 public static Vector3d CastVector3d()
1885 {
1886 return new Vector3d(0, 0, 0);
1887 }
1888
1889 public static Vector4d CastVector4d(double x, double y, double z, double w)
1890 {
1891 return new Vector4d(x, y, z, w);
1892 }
1893 public static Vector4d CastVector4d()
1894 {
1895 return new Vector4d(0, 0, 0, 0);
1896 }
1897
1898 public static BoundingSphere3f CastBoundingsphere3f(float x, float y, float z, float r)
1899 {
1900 return new BoundingSphere3f(new Vector3f(x, y, z), r);
1901 }
1902 public static BoundingSphere3d CastBoundingsphere3d(double x, double y, double z, double r)
1903 {
1904 return new BoundingSphere3d(new Vector3d(x, y, z), (float)r);
1905 }
1906
1907 public static BoundingSphere3f CastBoundingsphere3f()
1908 {
1909 return new BoundingSphere3f(new Vector3f(0, 0, 0), 0);
1910 }
1911 public static BoundingSphere3d CastBoundingsphere3d()
1912 {
1913 return new BoundingSphere3d(new Vector3d(0, 0, 0), (float)0);
1914 }
1915
1916
1917 public static BoundingBox3f3f CastBoundingbox3f3f(float x, float y, float z, float dx, float dy, float dz)
1918 {
1919 return new BoundingBox3f3f(x, y, z, dx, dy, dz);
1920 }
1921 public static BoundingBox3d3f CastBoundingbox3d3f(double x, double y, double z, double dx, double dy, double dz)
1922 {
1923 return new BoundingBox3d3f(x, y, z, (float)dx, (float)dy, (float)dz);
1924 }
1925
1926 public static BoundingBox3f3f CastBoundingbox3f3f()
1927 {
1928 return new BoundingBox3f3f(new Vector3f(0, 0, 0), new Vector3f(0, 0, 0));
1929 }
1930 public static BoundingBox3d3f CastBoundingbox3d3f()
1931 {
1932 return new BoundingBox3d3f(0, 0, 0, 0, 0, 0);
1933 }
1934
1935
1936
1937 public static Quaternion CastQuaternion(float x, float y, float z)
1938 {
1939 float neg = (x > 1.5 || y > 1.5 || z > 1.5) ? -1.0f : 1.0f;
1940 if (x > 1.5)
1941 x -= 3.0f;
1942 if (y > 1.5)
1943 y -= 3.0f;
1944 if (z > 1.5)
1945 z -= 3.0f;
1946 return new Quaternion(neg - neg * (float)Math.Sqrt(x * x + y * y + z * z), x, y, z);
1947 }
1948 public static Quaternion CastQuaternion()
1949 {
1950 return new Quaternion(1, 0, 0, 0);
1951 }
1952
1953 public static UUID CastUuid(Google.ProtocolBuffers.ByteString input)
1954 {
1955 return new UUID(input);
1956 }
1957 public static SHA256 CastSha256(Google.ProtocolBuffers.ByteString input)
1958 {
1959 return new SHA256(input);
1960 }
1961 public static SHA256 CastSha256()
1962 {
1963 return SHA256.Empty;
1964 }
1965 public static UUID CastUuid()
1966 {
1967 return UUID.Empty;
1968 }
1969
1970 public static float CastAngle(float d)
1971 {
1972 return d;
1973 }
1974 public static float CastAngle()
1975 {
1976 return 0;
1977 }
1978
1979 public static Time CastTime(ulong t)
1980 {
1981 return new Time(t);
1982 }
1983 public static Time CastTime()
1984 {
1985 return new Time(0);
1986 }
1987 public static Duration CastDuration(long t)
1988 {
1989 return new Duration(t);
1990 }
1991 public static Duration CastDuration()
1992 {
1993 return new Duration(0);
1994 }
1995
1996 public static T Construct<T>(T retval)
1997 {
1998 return retval;
1999 }
2000 public static long Construct(Duration d)
2001 {
2002 return d.toMicro();
2003 }
2004 public static ulong Construct(Time t)
2005 {
2006 return t.toMicro();
2007 }
2008 public static Google.ProtocolBuffers.ByteString Construct(UUID u)
2009 {
2010 byte[] data = u.GetUUID();
2011 Google.ProtocolBuffers.ByteString retval = Google.ProtocolBuffers.ByteString.CopyFrom(data, 0, 16);
2012 return retval;
2013 }
2014 public static Google.ProtocolBuffers.ByteString Construct(SHA256 u)
2015 {
2016 byte[] data = u.GetBinaryData();
2017 Google.ProtocolBuffers.ByteString retval = Google.ProtocolBuffers.ByteString.CopyFrom(data, 0, 16);
2018 return retval;
2019 }
2020 public static float[] ConstructNormal(Vector3f d)
2021 {
2022 return new float[] { d.x + (d.z < 0 ? 3.0f : 0.0f), d.y };
2023 }
2024 public static float[] ConstructQuaternion(Quaternion d)
2025 {
2026 return new float[] { d.x + (d.w < 0 ? 3.0f : 0.0f), d.y, d.z };
2027 }
2028
2029 public static float[] ConstructVector2f(Vector2f d)
2030 {
2031 return new float[] { d.x, d.y };
2032 }
2033 public static double[] ConstructVector2d(Vector2d d)
2034 {
2035 return new double[] { d.x, d.y };
2036 }
2037
2038 public static float[] ConstructVector3f(Vector3f d)
2039 {
2040 return new float[] { d.x, d.y, d.z };
2041 }
2042 public static double[] ConstructVector3d(Vector3d d)
2043 {
2044 return new double[] { d.x, d.y, d.z };
2045 }
2046 public static float[] ConstructVector4f(Vector4f d)
2047 {
2048 return new float[] { d.x, d.y, d.z, d.w };
2049 }
2050 public static double[] ConstructVector4d(Vector4d d)
2051 {
2052 return new double[] { d.x, d.y, d.z, d.w };
2053 }
2054
2055
2056 public static float[] ConstructBoundingsphere3f(BoundingSphere3f d)
2057 {
2058 return new float[] { d.Center.x, d.Center.y, d.Center.z, d.Radius };
2059 }
2060 public static double[] ConstructBoundingsphere3d(BoundingSphere3d d)
2061 {
2062 return new double[] { d.Center.x, d.Center.y, d.Center.z, d.Radius };
2063 }
2064
2065 public static float[] ConstructBoundingbox3f3f(BoundingBox3f3f d)
2066 {
2067 return new float[] { d.Min.x, d.Min.y, d.Min.z, d.Diag.x, d.Diag.y, d.Diag.z };
2068 }
2069 public static double[] ConstructBoundingbox3d3f(BoundingBox3d3f d)
2070 {
2071 return new double[] { d.Min.x, d.Min.y, d.Min.z, d.Diag.x, d.Diag.y, d.Diag.z };
2072 }
2073
2074
2075 }
2076
2077}
diff --git a/OpenSim/Client/Sirikata/Protocol/Persistence.cs b/OpenSim/Client/Sirikata/Protocol/Persistence.cs
new file mode 100644
index 0000000..d8f8d33
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Persistence.cs
@@ -0,0 +1,3299 @@
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2
3using pb = global::Google.ProtocolBuffers;
4using pbc = global::Google.ProtocolBuffers.Collections;
5using pbd = global::Google.ProtocolBuffers.Descriptors;
6using scg = global::System.Collections.Generic;
7namespace 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
new file mode 100644
index 0000000..54ca1f4
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs
@@ -0,0 +1,1516 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.Persistence.Protocol {
4 public class StorageKey : PBJ.IMessage {
5 protected _PBJ_Internal.StorageKey super;
6 public _PBJ_Internal.StorageKey _PBJSuper{ get { return super;} }
7 public StorageKey() {
8 super=new _PBJ_Internal.StorageKey();
9 }
10 public StorageKey(_PBJ_Internal.StorageKey reference) {
11 super=reference;
12 }
13 public static StorageKey defaultInstance= new StorageKey (_PBJ_Internal.StorageKey.DefaultInstance);
14 public static StorageKey DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.StorageKey.Descriptor; } }
19 public static class Types {
20 }
21 public static bool WithinReservedFieldTagRange(int field_tag) {
22 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
23 }
24 public static bool WithinExtensionFieldTagRange(int field_tag) {
25 return false;
26 }
27 public const int ObjectUuidFieldTag=9;
28 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
29 public PBJ.UUID ObjectUuid{ get {
30 if (HasObjectUuid) {
31 return PBJ._PBJ.CastUuid(super.ObjectUuid);
32 } else {
33 return PBJ._PBJ.CastUuid();
34 }
35 }
36 }
37 public const int FieldIdFieldTag=10;
38 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
39 public ulong FieldId{ get {
40 if (HasFieldId) {
41 return PBJ._PBJ.CastUint64(super.FieldId);
42 } else {
43 return PBJ._PBJ.CastUint64();
44 }
45 }
46 }
47 public const int FieldNameFieldTag=11;
48 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
49 public string FieldName{ get {
50 if (HasFieldName) {
51 return PBJ._PBJ.CastString(super.FieldName);
52 } else {
53 return PBJ._PBJ.CastString();
54 }
55 }
56 }
57 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
58 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
59 public static Builder CreateBuilder() { return new Builder(); }
60 public static Builder CreateBuilder(StorageKey prototype) {
61 return (Builder)new Builder().MergeFrom(prototype);
62 }
63 public static StorageKey ParseFrom(pb::ByteString data) {
64 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
65 }
66 public static StorageKey ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
67 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
68 }
69 public static StorageKey ParseFrom(byte[] data) {
70 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
71 }
72 public static StorageKey ParseFrom(byte[] data, pb::ExtensionRegistry er) {
73 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
74 }
75 public static StorageKey ParseFrom(global::System.IO.Stream data) {
76 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
77 }
78 public static StorageKey ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
79 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
80 }
81 public static StorageKey ParseFrom(pb::CodedInputStream data) {
82 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
83 }
84 public static StorageKey ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
85 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
86 }
87 protected override bool _HasAllPBJFields{ get {
88 return true
89 ;
90 } }
91 public bool IsInitialized { get {
92 return super.IsInitialized&&_HasAllPBJFields;
93 } }
94 public class Builder : global::PBJ.IMessage.IBuilder{
95 protected override bool _HasAllPBJFields{ get {
96 return true
97 ;
98 } }
99 public bool IsInitialized { get {
100 return super.IsInitialized&&_HasAllPBJFields;
101 } }
102 protected _PBJ_Internal.StorageKey.Builder super;
103 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
104 public _PBJ_Internal.StorageKey.Builder _PBJSuper{ get { return super;} }
105 public Builder() {super = new _PBJ_Internal.StorageKey.Builder();}
106 public Builder(_PBJ_Internal.StorageKey.Builder other) {
107 super=other;
108 }
109 public Builder Clone() {return new Builder(super.Clone());}
110 public Builder MergeFrom(StorageKey prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
111 public Builder Clear() {super.Clear();return this;}
112 public StorageKey BuildPartial() {return new StorageKey(super.BuildPartial());}
113 public StorageKey Build() {if (_HasAllPBJFields) return new StorageKey(super.Build());return null;}
114 public pbd::MessageDescriptor DescriptorForType {
115 get { return StorageKey.Descriptor; } }
116 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
117 public const int ObjectUuidFieldTag=9;
118 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
119 public PBJ.UUID ObjectUuid{ get {
120 if (HasObjectUuid) {
121 return PBJ._PBJ.CastUuid(super.ObjectUuid);
122 } else {
123 return PBJ._PBJ.CastUuid();
124 }
125 }
126 set {
127 super.ObjectUuid=(PBJ._PBJ.Construct(value));
128 }
129 }
130 public Builder ClearFieldId() { super.ClearFieldId();return this;}
131 public const int FieldIdFieldTag=10;
132 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
133 public ulong FieldId{ get {
134 if (HasFieldId) {
135 return PBJ._PBJ.CastUint64(super.FieldId);
136 } else {
137 return PBJ._PBJ.CastUint64();
138 }
139 }
140 set {
141 super.FieldId=(PBJ._PBJ.Construct(value));
142 }
143 }
144 public Builder ClearFieldName() { super.ClearFieldName();return this;}
145 public const int FieldNameFieldTag=11;
146 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
147 public string FieldName{ get {
148 if (HasFieldName) {
149 return PBJ._PBJ.CastString(super.FieldName);
150 } else {
151 return PBJ._PBJ.CastString();
152 }
153 }
154 set {
155 super.FieldName=(PBJ._PBJ.Construct(value));
156 }
157 }
158 }
159 }
160}
161namespace Sirikata.Persistence.Protocol {
162 public class StorageValue : PBJ.IMessage {
163 protected _PBJ_Internal.StorageValue super;
164 public _PBJ_Internal.StorageValue _PBJSuper{ get { return super;} }
165 public StorageValue() {
166 super=new _PBJ_Internal.StorageValue();
167 }
168 public StorageValue(_PBJ_Internal.StorageValue reference) {
169 super=reference;
170 }
171 public static StorageValue defaultInstance= new StorageValue (_PBJ_Internal.StorageValue.DefaultInstance);
172 public static StorageValue DefaultInstance{
173 get {return defaultInstance;}
174 }
175 public static pbd.MessageDescriptor Descriptor {
176 get { return _PBJ_Internal.StorageValue.Descriptor; } }
177 public static class Types {
178 }
179 public static bool WithinReservedFieldTagRange(int field_tag) {
180 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
181 }
182 public static bool WithinExtensionFieldTagRange(int field_tag) {
183 return false;
184 }
185 public const int DataFieldTag=12;
186 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
187 public pb::ByteString Data{ get {
188 if (HasData) {
189 return PBJ._PBJ.CastBytes(super.Data);
190 } else {
191 return PBJ._PBJ.CastBytes();
192 }
193 }
194 }
195 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
196 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
197 public static Builder CreateBuilder() { return new Builder(); }
198 public static Builder CreateBuilder(StorageValue prototype) {
199 return (Builder)new Builder().MergeFrom(prototype);
200 }
201 public static StorageValue ParseFrom(pb::ByteString data) {
202 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
203 }
204 public static StorageValue ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
205 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
206 }
207 public static StorageValue ParseFrom(byte[] data) {
208 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
209 }
210 public static StorageValue ParseFrom(byte[] data, pb::ExtensionRegistry er) {
211 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
212 }
213 public static StorageValue ParseFrom(global::System.IO.Stream data) {
214 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
215 }
216 public static StorageValue ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
217 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
218 }
219 public static StorageValue ParseFrom(pb::CodedInputStream data) {
220 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
221 }
222 public static StorageValue ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
223 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
224 }
225 protected override bool _HasAllPBJFields{ get {
226 return true
227 ;
228 } }
229 public bool IsInitialized { get {
230 return super.IsInitialized&&_HasAllPBJFields;
231 } }
232 public class Builder : global::PBJ.IMessage.IBuilder{
233 protected override bool _HasAllPBJFields{ get {
234 return true
235 ;
236 } }
237 public bool IsInitialized { get {
238 return super.IsInitialized&&_HasAllPBJFields;
239 } }
240 protected _PBJ_Internal.StorageValue.Builder super;
241 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
242 public _PBJ_Internal.StorageValue.Builder _PBJSuper{ get { return super;} }
243 public Builder() {super = new _PBJ_Internal.StorageValue.Builder();}
244 public Builder(_PBJ_Internal.StorageValue.Builder other) {
245 super=other;
246 }
247 public Builder Clone() {return new Builder(super.Clone());}
248 public Builder MergeFrom(StorageValue prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
249 public Builder Clear() {super.Clear();return this;}
250 public StorageValue BuildPartial() {return new StorageValue(super.BuildPartial());}
251 public StorageValue Build() {if (_HasAllPBJFields) return new StorageValue(super.Build());return null;}
252 public pbd::MessageDescriptor DescriptorForType {
253 get { return StorageValue.Descriptor; } }
254 public Builder ClearData() { super.ClearData();return this;}
255 public const int DataFieldTag=12;
256 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
257 public pb::ByteString Data{ get {
258 if (HasData) {
259 return PBJ._PBJ.CastBytes(super.Data);
260 } else {
261 return PBJ._PBJ.CastBytes();
262 }
263 }
264 set {
265 super.Data=(PBJ._PBJ.Construct(value));
266 }
267 }
268 }
269 }
270}
271namespace Sirikata.Persistence.Protocol {
272 public class StorageElement : PBJ.IMessage {
273 protected _PBJ_Internal.StorageElement super;
274 public _PBJ_Internal.StorageElement _PBJSuper{ get { return super;} }
275 public StorageElement() {
276 super=new _PBJ_Internal.StorageElement();
277 }
278 public StorageElement(_PBJ_Internal.StorageElement reference) {
279 super=reference;
280 }
281 public static StorageElement defaultInstance= new StorageElement (_PBJ_Internal.StorageElement.DefaultInstance);
282 public static StorageElement DefaultInstance{
283 get {return defaultInstance;}
284 }
285 public static pbd.MessageDescriptor Descriptor {
286 get { return _PBJ_Internal.StorageElement.Descriptor; } }
287 public static class Types {
288 public enum ReturnStatus {
289 KEY_MISSING=_PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING,
290 INTERNAL_ERROR=_PBJ_Internal.StorageElement.Types.ReturnStatus.INTERNAL_ERROR
291 };
292 }
293 public static bool WithinReservedFieldTagRange(int field_tag) {
294 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
295 }
296 public static bool WithinExtensionFieldTagRange(int field_tag) {
297 return false;
298 }
299 public const int ObjectUuidFieldTag=9;
300 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
301 public PBJ.UUID ObjectUuid{ get {
302 if (HasObjectUuid) {
303 return PBJ._PBJ.CastUuid(super.ObjectUuid);
304 } else {
305 return PBJ._PBJ.CastUuid();
306 }
307 }
308 }
309 public const int FieldIdFieldTag=10;
310 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
311 public ulong FieldId{ get {
312 if (HasFieldId) {
313 return PBJ._PBJ.CastUint64(super.FieldId);
314 } else {
315 return PBJ._PBJ.CastUint64();
316 }
317 }
318 }
319 public const int FieldNameFieldTag=11;
320 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
321 public string FieldName{ get {
322 if (HasFieldName) {
323 return PBJ._PBJ.CastString(super.FieldName);
324 } else {
325 return PBJ._PBJ.CastString();
326 }
327 }
328 }
329 public const int DataFieldTag=12;
330 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
331 public pb::ByteString Data{ get {
332 if (HasData) {
333 return PBJ._PBJ.CastBytes(super.Data);
334 } else {
335 return PBJ._PBJ.CastBytes();
336 }
337 }
338 }
339 public const int IndexFieldTag=13;
340 public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} }
341 public int Index{ get {
342 if (HasIndex) {
343 return PBJ._PBJ.CastInt32(super.Index);
344 } else {
345 return PBJ._PBJ.CastInt32();
346 }
347 }
348 }
349 public const int ReturnStatusFieldTag=15;
350 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
351 public Types.ReturnStatus ReturnStatus{ get {
352 if (HasReturnStatus) {
353 return (Types.ReturnStatus)super.ReturnStatus;
354 } else {
355 return new Types.ReturnStatus();
356 }
357 }
358 }
359 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
360 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
361 public static Builder CreateBuilder() { return new Builder(); }
362 public static Builder CreateBuilder(StorageElement prototype) {
363 return (Builder)new Builder().MergeFrom(prototype);
364 }
365 public static StorageElement ParseFrom(pb::ByteString data) {
366 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
367 }
368 public static StorageElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
369 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
370 }
371 public static StorageElement ParseFrom(byte[] data) {
372 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
373 }
374 public static StorageElement ParseFrom(byte[] data, pb::ExtensionRegistry er) {
375 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
376 }
377 public static StorageElement ParseFrom(global::System.IO.Stream data) {
378 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
379 }
380 public static StorageElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
381 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
382 }
383 public static StorageElement ParseFrom(pb::CodedInputStream data) {
384 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
385 }
386 public static StorageElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
387 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
388 }
389 protected override bool _HasAllPBJFields{ get {
390 return true
391 ;
392 } }
393 public bool IsInitialized { get {
394 return super.IsInitialized&&_HasAllPBJFields;
395 } }
396 public class Builder : global::PBJ.IMessage.IBuilder{
397 protected override bool _HasAllPBJFields{ get {
398 return true
399 ;
400 } }
401 public bool IsInitialized { get {
402 return super.IsInitialized&&_HasAllPBJFields;
403 } }
404 protected _PBJ_Internal.StorageElement.Builder super;
405 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
406 public _PBJ_Internal.StorageElement.Builder _PBJSuper{ get { return super;} }
407 public Builder() {super = new _PBJ_Internal.StorageElement.Builder();}
408 public Builder(_PBJ_Internal.StorageElement.Builder other) {
409 super=other;
410 }
411 public Builder Clone() {return new Builder(super.Clone());}
412 public Builder MergeFrom(StorageElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
413 public Builder Clear() {super.Clear();return this;}
414 public StorageElement BuildPartial() {return new StorageElement(super.BuildPartial());}
415 public StorageElement Build() {if (_HasAllPBJFields) return new StorageElement(super.Build());return null;}
416 public pbd::MessageDescriptor DescriptorForType {
417 get { return StorageElement.Descriptor; } }
418 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
419 public const int ObjectUuidFieldTag=9;
420 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
421 public PBJ.UUID ObjectUuid{ get {
422 if (HasObjectUuid) {
423 return PBJ._PBJ.CastUuid(super.ObjectUuid);
424 } else {
425 return PBJ._PBJ.CastUuid();
426 }
427 }
428 set {
429 super.ObjectUuid=(PBJ._PBJ.Construct(value));
430 }
431 }
432 public Builder ClearFieldId() { super.ClearFieldId();return this;}
433 public const int FieldIdFieldTag=10;
434 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
435 public ulong FieldId{ get {
436 if (HasFieldId) {
437 return PBJ._PBJ.CastUint64(super.FieldId);
438 } else {
439 return PBJ._PBJ.CastUint64();
440 }
441 }
442 set {
443 super.FieldId=(PBJ._PBJ.Construct(value));
444 }
445 }
446 public Builder ClearFieldName() { super.ClearFieldName();return this;}
447 public const int FieldNameFieldTag=11;
448 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
449 public string FieldName{ get {
450 if (HasFieldName) {
451 return PBJ._PBJ.CastString(super.FieldName);
452 } else {
453 return PBJ._PBJ.CastString();
454 }
455 }
456 set {
457 super.FieldName=(PBJ._PBJ.Construct(value));
458 }
459 }
460 public Builder ClearData() { super.ClearData();return this;}
461 public const int DataFieldTag=12;
462 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
463 public pb::ByteString Data{ get {
464 if (HasData) {
465 return PBJ._PBJ.CastBytes(super.Data);
466 } else {
467 return PBJ._PBJ.CastBytes();
468 }
469 }
470 set {
471 super.Data=(PBJ._PBJ.Construct(value));
472 }
473 }
474 public Builder ClearIndex() { super.ClearIndex();return this;}
475 public const int IndexFieldTag=13;
476 public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} }
477 public int Index{ get {
478 if (HasIndex) {
479 return PBJ._PBJ.CastInt32(super.Index);
480 } else {
481 return PBJ._PBJ.CastInt32();
482 }
483 }
484 set {
485 super.Index=(PBJ._PBJ.Construct(value));
486 }
487 }
488 public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;}
489 public const int ReturnStatusFieldTag=15;
490 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
491 public Types.ReturnStatus ReturnStatus{ get {
492 if (HasReturnStatus) {
493 return (Types.ReturnStatus)super.ReturnStatus;
494 } else {
495 return new Types.ReturnStatus();
496 }
497 }
498 set {
499 super.ReturnStatus=((_PBJ_Internal.StorageElement.Types.ReturnStatus)value);
500 }
501 }
502 }
503 }
504}
505namespace Sirikata.Persistence.Protocol {
506 public class CompareElement : PBJ.IMessage {
507 protected _PBJ_Internal.CompareElement super;
508 public _PBJ_Internal.CompareElement _PBJSuper{ get { return super;} }
509 public CompareElement() {
510 super=new _PBJ_Internal.CompareElement();
511 }
512 public CompareElement(_PBJ_Internal.CompareElement reference) {
513 super=reference;
514 }
515 public static CompareElement defaultInstance= new CompareElement (_PBJ_Internal.CompareElement.DefaultInstance);
516 public static CompareElement DefaultInstance{
517 get {return defaultInstance;}
518 }
519 public static pbd.MessageDescriptor Descriptor {
520 get { return _PBJ_Internal.CompareElement.Descriptor; } }
521 public static class Types {
522 public enum COMPARATOR {
523 EQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL,
524 NEQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.NEQUAL
525 };
526 }
527 public static bool WithinReservedFieldTagRange(int field_tag) {
528 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
529 }
530 public static bool WithinExtensionFieldTagRange(int field_tag) {
531 return false;
532 }
533 public const int ObjectUuidFieldTag=9;
534 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
535 public PBJ.UUID ObjectUuid{ get {
536 if (HasObjectUuid) {
537 return PBJ._PBJ.CastUuid(super.ObjectUuid);
538 } else {
539 return PBJ._PBJ.CastUuid();
540 }
541 }
542 }
543 public const int FieldIdFieldTag=10;
544 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
545 public ulong FieldId{ get {
546 if (HasFieldId) {
547 return PBJ._PBJ.CastUint64(super.FieldId);
548 } else {
549 return PBJ._PBJ.CastUint64();
550 }
551 }
552 }
553 public const int FieldNameFieldTag=11;
554 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
555 public string FieldName{ get {
556 if (HasFieldName) {
557 return PBJ._PBJ.CastString(super.FieldName);
558 } else {
559 return PBJ._PBJ.CastString();
560 }
561 }
562 }
563 public const int DataFieldTag=12;
564 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
565 public pb::ByteString Data{ get {
566 if (HasData) {
567 return PBJ._PBJ.CastBytes(super.Data);
568 } else {
569 return PBJ._PBJ.CastBytes();
570 }
571 }
572 }
573 public const int ComparatorFieldTag=14;
574 public bool HasComparator{ get {return super.HasComparator;} }
575 public Types.COMPARATOR Comparator{ get {
576 if (HasComparator) {
577 return (Types.COMPARATOR)super.Comparator;
578 } else {
579 return new Types.COMPARATOR();
580 }
581 }
582 }
583 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
584 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
585 public static Builder CreateBuilder() { return new Builder(); }
586 public static Builder CreateBuilder(CompareElement prototype) {
587 return (Builder)new Builder().MergeFrom(prototype);
588 }
589 public static CompareElement ParseFrom(pb::ByteString data) {
590 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
591 }
592 public static CompareElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
593 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
594 }
595 public static CompareElement ParseFrom(byte[] data) {
596 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
597 }
598 public static CompareElement ParseFrom(byte[] data, pb::ExtensionRegistry er) {
599 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
600 }
601 public static CompareElement ParseFrom(global::System.IO.Stream data) {
602 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
603 }
604 public static CompareElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
605 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
606 }
607 public static CompareElement ParseFrom(pb::CodedInputStream data) {
608 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
609 }
610 public static CompareElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
611 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
612 }
613 protected override bool _HasAllPBJFields{ get {
614 return true
615 ;
616 } }
617 public bool IsInitialized { get {
618 return super.IsInitialized&&_HasAllPBJFields;
619 } }
620 public class Builder : global::PBJ.IMessage.IBuilder{
621 protected override bool _HasAllPBJFields{ get {
622 return true
623 ;
624 } }
625 public bool IsInitialized { get {
626 return super.IsInitialized&&_HasAllPBJFields;
627 } }
628 protected _PBJ_Internal.CompareElement.Builder super;
629 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
630 public _PBJ_Internal.CompareElement.Builder _PBJSuper{ get { return super;} }
631 public Builder() {super = new _PBJ_Internal.CompareElement.Builder();}
632 public Builder(_PBJ_Internal.CompareElement.Builder other) {
633 super=other;
634 }
635 public Builder Clone() {return new Builder(super.Clone());}
636 public Builder MergeFrom(CompareElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
637 public Builder Clear() {super.Clear();return this;}
638 public CompareElement BuildPartial() {return new CompareElement(super.BuildPartial());}
639 public CompareElement Build() {if (_HasAllPBJFields) return new CompareElement(super.Build());return null;}
640 public pbd::MessageDescriptor DescriptorForType {
641 get { return CompareElement.Descriptor; } }
642 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
643 public const int ObjectUuidFieldTag=9;
644 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
645 public PBJ.UUID ObjectUuid{ get {
646 if (HasObjectUuid) {
647 return PBJ._PBJ.CastUuid(super.ObjectUuid);
648 } else {
649 return PBJ._PBJ.CastUuid();
650 }
651 }
652 set {
653 super.ObjectUuid=(PBJ._PBJ.Construct(value));
654 }
655 }
656 public Builder ClearFieldId() { super.ClearFieldId();return this;}
657 public const int FieldIdFieldTag=10;
658 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
659 public ulong FieldId{ get {
660 if (HasFieldId) {
661 return PBJ._PBJ.CastUint64(super.FieldId);
662 } else {
663 return PBJ._PBJ.CastUint64();
664 }
665 }
666 set {
667 super.FieldId=(PBJ._PBJ.Construct(value));
668 }
669 }
670 public Builder ClearFieldName() { super.ClearFieldName();return this;}
671 public const int FieldNameFieldTag=11;
672 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
673 public string FieldName{ get {
674 if (HasFieldName) {
675 return PBJ._PBJ.CastString(super.FieldName);
676 } else {
677 return PBJ._PBJ.CastString();
678 }
679 }
680 set {
681 super.FieldName=(PBJ._PBJ.Construct(value));
682 }
683 }
684 public Builder ClearData() { super.ClearData();return this;}
685 public const int DataFieldTag=12;
686 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
687 public pb::ByteString Data{ get {
688 if (HasData) {
689 return PBJ._PBJ.CastBytes(super.Data);
690 } else {
691 return PBJ._PBJ.CastBytes();
692 }
693 }
694 set {
695 super.Data=(PBJ._PBJ.Construct(value));
696 }
697 }
698 public Builder ClearComparator() { super.ClearComparator();return this;}
699 public const int ComparatorFieldTag=14;
700 public bool HasComparator{ get {return super.HasComparator;} }
701 public Types.COMPARATOR Comparator{ get {
702 if (HasComparator) {
703 return (Types.COMPARATOR)super.Comparator;
704 } else {
705 return new Types.COMPARATOR();
706 }
707 }
708 set {
709 super.Comparator=((_PBJ_Internal.CompareElement.Types.COMPARATOR)value);
710 }
711 }
712 }
713 }
714}
715namespace Sirikata.Persistence.Protocol {
716 public class StorageSet : PBJ.IMessage {
717 protected _PBJ_Internal.StorageSet super;
718 public _PBJ_Internal.StorageSet _PBJSuper{ get { return super;} }
719 public StorageSet() {
720 super=new _PBJ_Internal.StorageSet();
721 }
722 public StorageSet(_PBJ_Internal.StorageSet reference) {
723 super=reference;
724 }
725 public static StorageSet defaultInstance= new StorageSet (_PBJ_Internal.StorageSet.DefaultInstance);
726 public static StorageSet DefaultInstance{
727 get {return defaultInstance;}
728 }
729 public static pbd.MessageDescriptor Descriptor {
730 get { return _PBJ_Internal.StorageSet.Descriptor; } }
731 public static class Types {
732 }
733 public static bool WithinReservedFieldTagRange(int field_tag) {
734 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
735 }
736 public static bool WithinExtensionFieldTagRange(int field_tag) {
737 return false;
738 }
739 public const int ReadsFieldTag=9;
740 public int ReadsCount { get { return super.ReadsCount;} }
741 public bool HasReads(int index) {return true;}
742 public StorageElement Reads(int index) {
743 return new StorageElement(super.GetReads(index));
744 }
745 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
746 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
747 public static Builder CreateBuilder() { return new Builder(); }
748 public static Builder CreateBuilder(StorageSet prototype) {
749 return (Builder)new Builder().MergeFrom(prototype);
750 }
751 public static StorageSet ParseFrom(pb::ByteString data) {
752 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
753 }
754 public static StorageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
755 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
756 }
757 public static StorageSet ParseFrom(byte[] data) {
758 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
759 }
760 public static StorageSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
761 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
762 }
763 public static StorageSet ParseFrom(global::System.IO.Stream data) {
764 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
765 }
766 public static StorageSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
767 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
768 }
769 public static StorageSet ParseFrom(pb::CodedInputStream data) {
770 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
771 }
772 public static StorageSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
773 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
774 }
775 protected override bool _HasAllPBJFields{ get {
776 return true
777 ;
778 } }
779 public bool IsInitialized { get {
780 return super.IsInitialized&&_HasAllPBJFields;
781 } }
782 public class Builder : global::PBJ.IMessage.IBuilder{
783 protected override bool _HasAllPBJFields{ get {
784 return true
785 ;
786 } }
787 public bool IsInitialized { get {
788 return super.IsInitialized&&_HasAllPBJFields;
789 } }
790 protected _PBJ_Internal.StorageSet.Builder super;
791 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
792 public _PBJ_Internal.StorageSet.Builder _PBJSuper{ get { return super;} }
793 public Builder() {super = new _PBJ_Internal.StorageSet.Builder();}
794 public Builder(_PBJ_Internal.StorageSet.Builder other) {
795 super=other;
796 }
797 public Builder Clone() {return new Builder(super.Clone());}
798 public Builder MergeFrom(StorageSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
799 public Builder Clear() {super.Clear();return this;}
800 public StorageSet BuildPartial() {return new StorageSet(super.BuildPartial());}
801 public StorageSet Build() {if (_HasAllPBJFields) return new StorageSet(super.Build());return null;}
802 public pbd::MessageDescriptor DescriptorForType {
803 get { return StorageSet.Descriptor; } }
804 public Builder ClearReads() { super.ClearReads();return this;}
805 public Builder SetReads(int index,StorageElement value) {
806 super.SetReads(index,value._PBJSuper);
807 return this;
808 }
809 public const int ReadsFieldTag=9;
810 public int ReadsCount { get { return super.ReadsCount;} }
811 public bool HasReads(int index) {return true;}
812 public StorageElement Reads(int index) {
813 return new StorageElement(super.GetReads(index));
814 }
815 public Builder AddReads(StorageElement value ) {
816 super.AddReads(value._PBJSuper);
817 return this;
818 }
819 }
820 }
821}
822namespace Sirikata.Persistence.Protocol {
823 public class ReadSet : PBJ.IMessage {
824 protected _PBJ_Internal.ReadSet super;
825 public _PBJ_Internal.ReadSet _PBJSuper{ get { return super;} }
826 public ReadSet() {
827 super=new _PBJ_Internal.ReadSet();
828 }
829 public ReadSet(_PBJ_Internal.ReadSet reference) {
830 super=reference;
831 }
832 public static ReadSet defaultInstance= new ReadSet (_PBJ_Internal.ReadSet.DefaultInstance);
833 public static ReadSet DefaultInstance{
834 get {return defaultInstance;}
835 }
836 public static pbd.MessageDescriptor Descriptor {
837 get { return _PBJ_Internal.ReadSet.Descriptor; } }
838 public static class Types {
839 }
840 public static bool WithinReservedFieldTagRange(int field_tag) {
841 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
842 }
843 public static bool WithinExtensionFieldTagRange(int field_tag) {
844 return false;
845 }
846 public const int ReadsFieldTag=9;
847 public int ReadsCount { get { return super.ReadsCount;} }
848 public bool HasReads(int index) {return true;}
849 public StorageElement Reads(int index) {
850 return new StorageElement(super.GetReads(index));
851 }
852 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
853 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
854 public static Builder CreateBuilder() { return new Builder(); }
855 public static Builder CreateBuilder(ReadSet prototype) {
856 return (Builder)new Builder().MergeFrom(prototype);
857 }
858 public static ReadSet ParseFrom(pb::ByteString data) {
859 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
860 }
861 public static ReadSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
862 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
863 }
864 public static ReadSet ParseFrom(byte[] data) {
865 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
866 }
867 public static ReadSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
868 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
869 }
870 public static ReadSet ParseFrom(global::System.IO.Stream data) {
871 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
872 }
873 public static ReadSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
874 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
875 }
876 public static ReadSet ParseFrom(pb::CodedInputStream data) {
877 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
878 }
879 public static ReadSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
880 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
881 }
882 protected override bool _HasAllPBJFields{ get {
883 return true
884 ;
885 } }
886 public bool IsInitialized { get {
887 return super.IsInitialized&&_HasAllPBJFields;
888 } }
889 public class Builder : global::PBJ.IMessage.IBuilder{
890 protected override bool _HasAllPBJFields{ get {
891 return true
892 ;
893 } }
894 public bool IsInitialized { get {
895 return super.IsInitialized&&_HasAllPBJFields;
896 } }
897 protected _PBJ_Internal.ReadSet.Builder super;
898 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
899 public _PBJ_Internal.ReadSet.Builder _PBJSuper{ get { return super;} }
900 public Builder() {super = new _PBJ_Internal.ReadSet.Builder();}
901 public Builder(_PBJ_Internal.ReadSet.Builder other) {
902 super=other;
903 }
904 public Builder Clone() {return new Builder(super.Clone());}
905 public Builder MergeFrom(ReadSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
906 public Builder Clear() {super.Clear();return this;}
907 public ReadSet BuildPartial() {return new ReadSet(super.BuildPartial());}
908 public ReadSet Build() {if (_HasAllPBJFields) return new ReadSet(super.Build());return null;}
909 public pbd::MessageDescriptor DescriptorForType {
910 get { return ReadSet.Descriptor; } }
911 public Builder ClearReads() { super.ClearReads();return this;}
912 public Builder SetReads(int index,StorageElement value) {
913 super.SetReads(index,value._PBJSuper);
914 return this;
915 }
916 public const int ReadsFieldTag=9;
917 public int ReadsCount { get { return super.ReadsCount;} }
918 public bool HasReads(int index) {return true;}
919 public StorageElement Reads(int index) {
920 return new StorageElement(super.GetReads(index));
921 }
922 public Builder AddReads(StorageElement value ) {
923 super.AddReads(value._PBJSuper);
924 return this;
925 }
926 }
927 }
928}
929namespace Sirikata.Persistence.Protocol {
930 public class WriteSet : PBJ.IMessage {
931 protected _PBJ_Internal.WriteSet super;
932 public _PBJ_Internal.WriteSet _PBJSuper{ get { return super;} }
933 public WriteSet() {
934 super=new _PBJ_Internal.WriteSet();
935 }
936 public WriteSet(_PBJ_Internal.WriteSet reference) {
937 super=reference;
938 }
939 public static WriteSet defaultInstance= new WriteSet (_PBJ_Internal.WriteSet.DefaultInstance);
940 public static WriteSet DefaultInstance{
941 get {return defaultInstance;}
942 }
943 public static pbd.MessageDescriptor Descriptor {
944 get { return _PBJ_Internal.WriteSet.Descriptor; } }
945 public static class Types {
946 }
947 public static bool WithinReservedFieldTagRange(int field_tag) {
948 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
949 }
950 public static bool WithinExtensionFieldTagRange(int field_tag) {
951 return false;
952 }
953 public const int WritesFieldTag=10;
954 public int WritesCount { get { return super.WritesCount;} }
955 public bool HasWrites(int index) {return true;}
956 public StorageElement Writes(int index) {
957 return new StorageElement(super.GetWrites(index));
958 }
959 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
960 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
961 public static Builder CreateBuilder() { return new Builder(); }
962 public static Builder CreateBuilder(WriteSet prototype) {
963 return (Builder)new Builder().MergeFrom(prototype);
964 }
965 public static WriteSet ParseFrom(pb::ByteString data) {
966 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
967 }
968 public static WriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
969 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
970 }
971 public static WriteSet ParseFrom(byte[] data) {
972 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
973 }
974 public static WriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
975 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
976 }
977 public static WriteSet ParseFrom(global::System.IO.Stream data) {
978 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
979 }
980 public static WriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
981 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
982 }
983 public static WriteSet ParseFrom(pb::CodedInputStream data) {
984 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
985 }
986 public static WriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
987 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
988 }
989 protected override bool _HasAllPBJFields{ get {
990 return true
991 ;
992 } }
993 public bool IsInitialized { get {
994 return super.IsInitialized&&_HasAllPBJFields;
995 } }
996 public class Builder : global::PBJ.IMessage.IBuilder{
997 protected override bool _HasAllPBJFields{ get {
998 return true
999 ;
1000 } }
1001 public bool IsInitialized { get {
1002 return super.IsInitialized&&_HasAllPBJFields;
1003 } }
1004 protected _PBJ_Internal.WriteSet.Builder super;
1005 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1006 public _PBJ_Internal.WriteSet.Builder _PBJSuper{ get { return super;} }
1007 public Builder() {super = new _PBJ_Internal.WriteSet.Builder();}
1008 public Builder(_PBJ_Internal.WriteSet.Builder other) {
1009 super=other;
1010 }
1011 public Builder Clone() {return new Builder(super.Clone());}
1012 public Builder MergeFrom(WriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1013 public Builder Clear() {super.Clear();return this;}
1014 public WriteSet BuildPartial() {return new WriteSet(super.BuildPartial());}
1015 public WriteSet Build() {if (_HasAllPBJFields) return new WriteSet(super.Build());return null;}
1016 public pbd::MessageDescriptor DescriptorForType {
1017 get { return WriteSet.Descriptor; } }
1018 public Builder ClearWrites() { super.ClearWrites();return this;}
1019 public Builder SetWrites(int index,StorageElement value) {
1020 super.SetWrites(index,value._PBJSuper);
1021 return this;
1022 }
1023 public const int WritesFieldTag=10;
1024 public int WritesCount { get { return super.WritesCount;} }
1025 public bool HasWrites(int index) {return true;}
1026 public StorageElement Writes(int index) {
1027 return new StorageElement(super.GetWrites(index));
1028 }
1029 public Builder AddWrites(StorageElement value ) {
1030 super.AddWrites(value._PBJSuper);
1031 return this;
1032 }
1033 }
1034 }
1035}
1036namespace Sirikata.Persistence.Protocol {
1037 public class ReadWriteSet : PBJ.IMessage {
1038 protected _PBJ_Internal.ReadWriteSet super;
1039 public _PBJ_Internal.ReadWriteSet _PBJSuper{ get { return super;} }
1040 public ReadWriteSet() {
1041 super=new _PBJ_Internal.ReadWriteSet();
1042 }
1043 public ReadWriteSet(_PBJ_Internal.ReadWriteSet reference) {
1044 super=reference;
1045 }
1046 public static ReadWriteSet defaultInstance= new ReadWriteSet (_PBJ_Internal.ReadWriteSet.DefaultInstance);
1047 public static ReadWriteSet DefaultInstance{
1048 get {return defaultInstance;}
1049 }
1050 public static pbd.MessageDescriptor Descriptor {
1051 get { return _PBJ_Internal.ReadWriteSet.Descriptor; } }
1052 public static class Types {
1053 public enum ReadWriteSetOptions {
1054 RETURN_READ_NAMES=_PBJ_Internal.ReadWriteSet.Types.ReadWriteSetOptions.RETURN_READ_NAMES
1055 };
1056 }
1057 public static bool WithinReservedFieldTagRange(int field_tag) {
1058 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
1059 }
1060 public static bool WithinExtensionFieldTagRange(int field_tag) {
1061 return false;
1062 }
1063 public const int ReadsFieldTag=9;
1064 public int ReadsCount { get { return super.ReadsCount;} }
1065 public bool HasReads(int index) {return true;}
1066 public StorageElement Reads(int index) {
1067 return new StorageElement(super.GetReads(index));
1068 }
1069 public const int WritesFieldTag=10;
1070 public int WritesCount { get { return super.WritesCount;} }
1071 public bool HasWrites(int index) {return true;}
1072 public StorageElement Writes(int index) {
1073 return new StorageElement(super.GetWrites(index));
1074 }
1075 public const int OptionsFieldTag=14;
1076 public bool HasOptions { get {
1077 if (!super.HasOptions) return false;
1078 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1079 } }
1080 public ulong Options{ get {
1081 if (HasOptions) {
1082 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1083 } else {
1084 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1085 }
1086 }
1087 }
1088 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1089 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1090 public static Builder CreateBuilder() { return new Builder(); }
1091 public static Builder CreateBuilder(ReadWriteSet prototype) {
1092 return (Builder)new Builder().MergeFrom(prototype);
1093 }
1094 public static ReadWriteSet ParseFrom(pb::ByteString data) {
1095 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1096 }
1097 public static ReadWriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1098 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1099 }
1100 public static ReadWriteSet ParseFrom(byte[] data) {
1101 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1102 }
1103 public static ReadWriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1104 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1105 }
1106 public static ReadWriteSet ParseFrom(global::System.IO.Stream data) {
1107 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1108 }
1109 public static ReadWriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1110 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1111 }
1112 public static ReadWriteSet ParseFrom(pb::CodedInputStream data) {
1113 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1114 }
1115 public static ReadWriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1116 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1117 }
1118 protected override bool _HasAllPBJFields{ get {
1119 return true
1120 ;
1121 } }
1122 public bool IsInitialized { get {
1123 return super.IsInitialized&&_HasAllPBJFields;
1124 } }
1125 public class Builder : global::PBJ.IMessage.IBuilder{
1126 protected override bool _HasAllPBJFields{ get {
1127 return true
1128 ;
1129 } }
1130 public bool IsInitialized { get {
1131 return super.IsInitialized&&_HasAllPBJFields;
1132 } }
1133 protected _PBJ_Internal.ReadWriteSet.Builder super;
1134 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1135 public _PBJ_Internal.ReadWriteSet.Builder _PBJSuper{ get { return super;} }
1136 public Builder() {super = new _PBJ_Internal.ReadWriteSet.Builder();}
1137 public Builder(_PBJ_Internal.ReadWriteSet.Builder other) {
1138 super=other;
1139 }
1140 public Builder Clone() {return new Builder(super.Clone());}
1141 public Builder MergeFrom(ReadWriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1142 public Builder Clear() {super.Clear();return this;}
1143 public ReadWriteSet BuildPartial() {return new ReadWriteSet(super.BuildPartial());}
1144 public ReadWriteSet Build() {if (_HasAllPBJFields) return new ReadWriteSet(super.Build());return null;}
1145 public pbd::MessageDescriptor DescriptorForType {
1146 get { return ReadWriteSet.Descriptor; } }
1147 public Builder ClearReads() { super.ClearReads();return this;}
1148 public Builder SetReads(int index,StorageElement value) {
1149 super.SetReads(index,value._PBJSuper);
1150 return this;
1151 }
1152 public const int ReadsFieldTag=9;
1153 public int ReadsCount { get { return super.ReadsCount;} }
1154 public bool HasReads(int index) {return true;}
1155 public StorageElement Reads(int index) {
1156 return new StorageElement(super.GetReads(index));
1157 }
1158 public Builder AddReads(StorageElement value ) {
1159 super.AddReads(value._PBJSuper);
1160 return this;
1161 }
1162 public Builder ClearWrites() { super.ClearWrites();return this;}
1163 public Builder SetWrites(int index,StorageElement value) {
1164 super.SetWrites(index,value._PBJSuper);
1165 return this;
1166 }
1167 public const int WritesFieldTag=10;
1168 public int WritesCount { get { return super.WritesCount;} }
1169 public bool HasWrites(int index) {return true;}
1170 public StorageElement Writes(int index) {
1171 return new StorageElement(super.GetWrites(index));
1172 }
1173 public Builder AddWrites(StorageElement value ) {
1174 super.AddWrites(value._PBJSuper);
1175 return this;
1176 }
1177 public Builder ClearOptions() { super.ClearOptions();return this;}
1178 public const int OptionsFieldTag=14;
1179 public bool HasOptions { get {
1180 if (!super.HasOptions) return false;
1181 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1182 } }
1183 public ulong Options{ get {
1184 if (HasOptions) {
1185 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1186 } else {
1187 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1188 }
1189 }
1190 set {
1191 super.Options=((value));
1192 }
1193 }
1194 }
1195 }
1196}
1197namespace Sirikata.Persistence.Protocol {
1198 public class Minitransaction : PBJ.IMessage {
1199 protected _PBJ_Internal.Minitransaction super;
1200 public _PBJ_Internal.Minitransaction _PBJSuper{ get { return super;} }
1201 public Minitransaction() {
1202 super=new _PBJ_Internal.Minitransaction();
1203 }
1204 public Minitransaction(_PBJ_Internal.Minitransaction reference) {
1205 super=reference;
1206 }
1207 public static Minitransaction defaultInstance= new Minitransaction (_PBJ_Internal.Minitransaction.DefaultInstance);
1208 public static Minitransaction DefaultInstance{
1209 get {return defaultInstance;}
1210 }
1211 public static pbd.MessageDescriptor Descriptor {
1212 get { return _PBJ_Internal.Minitransaction.Descriptor; } }
1213 public static class Types {
1214 public enum TransactionOptions {
1215 RETURN_READ_NAMES=_PBJ_Internal.Minitransaction.Types.TransactionOptions.RETURN_READ_NAMES
1216 };
1217 }
1218 public static bool WithinReservedFieldTagRange(int field_tag) {
1219 return false;
1220 }
1221 public static bool WithinExtensionFieldTagRange(int field_tag) {
1222 return false;
1223 }
1224 public const int ReadsFieldTag=9;
1225 public int ReadsCount { get { return super.ReadsCount;} }
1226 public bool HasReads(int index) {return true;}
1227 public StorageElement Reads(int index) {
1228 return new StorageElement(super.GetReads(index));
1229 }
1230 public const int WritesFieldTag=10;
1231 public int WritesCount { get { return super.WritesCount;} }
1232 public bool HasWrites(int index) {return true;}
1233 public StorageElement Writes(int index) {
1234 return new StorageElement(super.GetWrites(index));
1235 }
1236 public const int ComparesFieldTag=11;
1237 public int ComparesCount { get { return super.ComparesCount;} }
1238 public bool HasCompares(int index) {return true;}
1239 public CompareElement Compares(int index) {
1240 return new CompareElement(super.GetCompares(index));
1241 }
1242 public const int OptionsFieldTag=14;
1243 public bool HasOptions { get {
1244 if (!super.HasOptions) return false;
1245 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1246 } }
1247 public ulong Options{ get {
1248 if (HasOptions) {
1249 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1250 } else {
1251 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1252 }
1253 }
1254 }
1255 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1256 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1257 public static Builder CreateBuilder() { return new Builder(); }
1258 public static Builder CreateBuilder(Minitransaction prototype) {
1259 return (Builder)new Builder().MergeFrom(prototype);
1260 }
1261 public static Minitransaction ParseFrom(pb::ByteString data) {
1262 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1263 }
1264 public static Minitransaction ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1265 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1266 }
1267 public static Minitransaction ParseFrom(byte[] data) {
1268 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1269 }
1270 public static Minitransaction ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1271 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1272 }
1273 public static Minitransaction ParseFrom(global::System.IO.Stream data) {
1274 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1275 }
1276 public static Minitransaction ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1277 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1278 }
1279 public static Minitransaction ParseFrom(pb::CodedInputStream data) {
1280 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1281 }
1282 public static Minitransaction ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1283 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1284 }
1285 protected override bool _HasAllPBJFields{ get {
1286 return true
1287 ;
1288 } }
1289 public bool IsInitialized { get {
1290 return super.IsInitialized&&_HasAllPBJFields;
1291 } }
1292 public class Builder : global::PBJ.IMessage.IBuilder{
1293 protected override bool _HasAllPBJFields{ get {
1294 return true
1295 ;
1296 } }
1297 public bool IsInitialized { get {
1298 return super.IsInitialized&&_HasAllPBJFields;
1299 } }
1300 protected _PBJ_Internal.Minitransaction.Builder super;
1301 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1302 public _PBJ_Internal.Minitransaction.Builder _PBJSuper{ get { return super;} }
1303 public Builder() {super = new _PBJ_Internal.Minitransaction.Builder();}
1304 public Builder(_PBJ_Internal.Minitransaction.Builder other) {
1305 super=other;
1306 }
1307 public Builder Clone() {return new Builder(super.Clone());}
1308 public Builder MergeFrom(Minitransaction prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1309 public Builder Clear() {super.Clear();return this;}
1310 public Minitransaction BuildPartial() {return new Minitransaction(super.BuildPartial());}
1311 public Minitransaction Build() {if (_HasAllPBJFields) return new Minitransaction(super.Build());return null;}
1312 public pbd::MessageDescriptor DescriptorForType {
1313 get { return Minitransaction.Descriptor; } }
1314 public Builder ClearReads() { super.ClearReads();return this;}
1315 public Builder SetReads(int index,StorageElement value) {
1316 super.SetReads(index,value._PBJSuper);
1317 return this;
1318 }
1319 public const int ReadsFieldTag=9;
1320 public int ReadsCount { get { return super.ReadsCount;} }
1321 public bool HasReads(int index) {return true;}
1322 public StorageElement Reads(int index) {
1323 return new StorageElement(super.GetReads(index));
1324 }
1325 public Builder AddReads(StorageElement value ) {
1326 super.AddReads(value._PBJSuper);
1327 return this;
1328 }
1329 public Builder ClearWrites() { super.ClearWrites();return this;}
1330 public Builder SetWrites(int index,StorageElement value) {
1331 super.SetWrites(index,value._PBJSuper);
1332 return this;
1333 }
1334 public const int WritesFieldTag=10;
1335 public int WritesCount { get { return super.WritesCount;} }
1336 public bool HasWrites(int index) {return true;}
1337 public StorageElement Writes(int index) {
1338 return new StorageElement(super.GetWrites(index));
1339 }
1340 public Builder AddWrites(StorageElement value ) {
1341 super.AddWrites(value._PBJSuper);
1342 return this;
1343 }
1344 public Builder ClearCompares() { super.ClearCompares();return this;}
1345 public Builder SetCompares(int index,CompareElement value) {
1346 super.SetCompares(index,value._PBJSuper);
1347 return this;
1348 }
1349 public const int ComparesFieldTag=11;
1350 public int ComparesCount { get { return super.ComparesCount;} }
1351 public bool HasCompares(int index) {return true;}
1352 public CompareElement Compares(int index) {
1353 return new CompareElement(super.GetCompares(index));
1354 }
1355 public Builder AddCompares(CompareElement value ) {
1356 super.AddCompares(value._PBJSuper);
1357 return this;
1358 }
1359 public Builder ClearOptions() { super.ClearOptions();return this;}
1360 public const int OptionsFieldTag=14;
1361 public bool HasOptions { get {
1362 if (!super.HasOptions) return false;
1363 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1364 } }
1365 public ulong Options{ get {
1366 if (HasOptions) {
1367 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1368 } else {
1369 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1370 }
1371 }
1372 set {
1373 super.Options=((value));
1374 }
1375 }
1376 }
1377 }
1378}
1379namespace Sirikata.Persistence.Protocol {
1380 public class Response : PBJ.IMessage {
1381 protected _PBJ_Internal.Response super;
1382 public _PBJ_Internal.Response _PBJSuper{ get { return super;} }
1383 public Response() {
1384 super=new _PBJ_Internal.Response();
1385 }
1386 public Response(_PBJ_Internal.Response reference) {
1387 super=reference;
1388 }
1389 public static Response defaultInstance= new Response (_PBJ_Internal.Response.DefaultInstance);
1390 public static Response DefaultInstance{
1391 get {return defaultInstance;}
1392 }
1393 public static pbd.MessageDescriptor Descriptor {
1394 get { return _PBJ_Internal.Response.Descriptor; } }
1395 public static class Types {
1396 public enum ReturnStatus {
1397 SUCCESS=_PBJ_Internal.Response.Types.ReturnStatus.SUCCESS,
1398 DATABASE_LOCKED=_PBJ_Internal.Response.Types.ReturnStatus.DATABASE_LOCKED,
1399 KEY_MISSING=_PBJ_Internal.Response.Types.ReturnStatus.KEY_MISSING,
1400 COMPARISON_FAILED=_PBJ_Internal.Response.Types.ReturnStatus.COMPARISON_FAILED,
1401 INTERNAL_ERROR=_PBJ_Internal.Response.Types.ReturnStatus.INTERNAL_ERROR
1402 };
1403 }
1404 public static bool WithinReservedFieldTagRange(int field_tag) {
1405 return false||(field_tag>=1&&field_tag<=8);
1406 }
1407 public static bool WithinExtensionFieldTagRange(int field_tag) {
1408 return false;
1409 }
1410 public const int ReadsFieldTag=9;
1411 public int ReadsCount { get { return super.ReadsCount;} }
1412 public bool HasReads(int index) {return true;}
1413 public StorageElement Reads(int index) {
1414 return new StorageElement(super.GetReads(index));
1415 }
1416 public const int ReturnStatusFieldTag=15;
1417 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
1418 public Types.ReturnStatus ReturnStatus{ get {
1419 if (HasReturnStatus) {
1420 return (Types.ReturnStatus)super.ReturnStatus;
1421 } else {
1422 return new Types.ReturnStatus();
1423 }
1424 }
1425 }
1426 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1427 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1428 public static Builder CreateBuilder() { return new Builder(); }
1429 public static Builder CreateBuilder(Response prototype) {
1430 return (Builder)new Builder().MergeFrom(prototype);
1431 }
1432 public static Response ParseFrom(pb::ByteString data) {
1433 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1434 }
1435 public static Response ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1436 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1437 }
1438 public static Response ParseFrom(byte[] data) {
1439 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1440 }
1441 public static Response ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1442 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1443 }
1444 public static Response ParseFrom(global::System.IO.Stream data) {
1445 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1446 }
1447 public static Response ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1448 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1449 }
1450 public static Response ParseFrom(pb::CodedInputStream data) {
1451 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1452 }
1453 public static Response ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1454 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1455 }
1456 protected override bool _HasAllPBJFields{ get {
1457 return true
1458 ;
1459 } }
1460 public bool IsInitialized { get {
1461 return super.IsInitialized&&_HasAllPBJFields;
1462 } }
1463 public class Builder : global::PBJ.IMessage.IBuilder{
1464 protected override bool _HasAllPBJFields{ get {
1465 return true
1466 ;
1467 } }
1468 public bool IsInitialized { get {
1469 return super.IsInitialized&&_HasAllPBJFields;
1470 } }
1471 protected _PBJ_Internal.Response.Builder super;
1472 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1473 public _PBJ_Internal.Response.Builder _PBJSuper{ get { return super;} }
1474 public Builder() {super = new _PBJ_Internal.Response.Builder();}
1475 public Builder(_PBJ_Internal.Response.Builder other) {
1476 super=other;
1477 }
1478 public Builder Clone() {return new Builder(super.Clone());}
1479 public Builder MergeFrom(Response prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1480 public Builder Clear() {super.Clear();return this;}
1481 public Response BuildPartial() {return new Response(super.BuildPartial());}
1482 public Response Build() {if (_HasAllPBJFields) return new Response(super.Build());return null;}
1483 public pbd::MessageDescriptor DescriptorForType {
1484 get { return Response.Descriptor; } }
1485 public Builder ClearReads() { super.ClearReads();return this;}
1486 public Builder SetReads(int index,StorageElement value) {
1487 super.SetReads(index,value._PBJSuper);
1488 return this;
1489 }
1490 public const int ReadsFieldTag=9;
1491 public int ReadsCount { get { return super.ReadsCount;} }
1492 public bool HasReads(int index) {return true;}
1493 public StorageElement Reads(int index) {
1494 return new StorageElement(super.GetReads(index));
1495 }
1496 public Builder AddReads(StorageElement value ) {
1497 super.AddReads(value._PBJSuper);
1498 return this;
1499 }
1500 public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;}
1501 public const int ReturnStatusFieldTag=15;
1502 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
1503 public Types.ReturnStatus ReturnStatus{ get {
1504 if (HasReturnStatus) {
1505 return (Types.ReturnStatus)super.ReturnStatus;
1506 } else {
1507 return new Types.ReturnStatus();
1508 }
1509 }
1510 set {
1511 super.ReturnStatus=((_PBJ_Internal.Response.Types.ReturnStatus)value);
1512 }
1513 }
1514 }
1515 }
1516}
diff --git a/OpenSim/Client/Sirikata/Protocol/Physics.cs b/OpenSim/Client/Sirikata/Protocol/Physics.cs
new file mode 100644
index 0000000..a81a6fd
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Physics.cs
@@ -0,0 +1,840 @@
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2
3using pb = global::Google.ProtocolBuffers;
4using pbc = global::Google.ProtocolBuffers.Collections;
5using pbd = global::Google.ProtocolBuffers.Descriptors;
6using scg = global::System.Collections.Generic;
7namespace 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
new file mode 100644
index 0000000..decd204
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Physics.pbj.cs
@@ -0,0 +1,394 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.Physics.Protocol {
4 public class CollisionBegin : PBJ.IMessage {
5 protected _PBJ_Internal.CollisionBegin super;
6 public _PBJ_Internal.CollisionBegin _PBJSuper{ get { return super;} }
7 public CollisionBegin() {
8 super=new _PBJ_Internal.CollisionBegin();
9 }
10 public CollisionBegin(_PBJ_Internal.CollisionBegin reference) {
11 super=reference;
12 }
13 public static CollisionBegin defaultInstance= new CollisionBegin (_PBJ_Internal.CollisionBegin.DefaultInstance);
14 public static CollisionBegin DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.CollisionBegin.Descriptor; } }
19 public static class Types {
20 }
21 public static bool WithinReservedFieldTagRange(int field_tag) {
22 return false;
23 }
24 public static bool WithinExtensionFieldTagRange(int field_tag) {
25 return false;
26 }
27 public const int TimestampFieldTag=2;
28 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
29 public PBJ.Time Timestamp{ get {
30 if (HasTimestamp) {
31 return PBJ._PBJ.CastTime(super.Timestamp);
32 } else {
33 return PBJ._PBJ.CastTime();
34 }
35 }
36 }
37 public const int ThisPositionFieldTag=3;
38 public int ThisPositionCount { get { return super.ThisPositionCount/3;} }
39 public bool HasThisPosition(int index) { return true; }
40 public PBJ.Vector3d GetThisPosition(int index) {
41 if (HasThisPosition(index)) {
42 return PBJ._PBJ.CastVector3d(super.GetThisPosition(index*3+0),super.GetThisPosition(index*3+1),super.GetThisPosition(index*3+2));
43 } else {
44 return PBJ._PBJ.CastVector3d();
45 }
46 }
47 public const int OtherPositionFieldTag=4;
48 public int OtherPositionCount { get { return super.OtherPositionCount/3;} }
49 public bool HasOtherPosition(int index) { return true; }
50 public PBJ.Vector3d GetOtherPosition(int index) {
51 if (HasOtherPosition(index)) {
52 return PBJ._PBJ.CastVector3d(super.GetOtherPosition(index*3+0),super.GetOtherPosition(index*3+1),super.GetOtherPosition(index*3+2));
53 } else {
54 return PBJ._PBJ.CastVector3d();
55 }
56 }
57 public const int ThisNormalFieldTag=5;
58 public int ThisNormalCount { get { return super.ThisNormalCount/2;} }
59 public bool HasThisNormal(int index) { return true; }
60 public PBJ.Vector3f GetThisNormal(int index) {
61 if (HasThisNormal(index)) {
62 return PBJ._PBJ.CastNormal(super.GetThisNormal(index*2+0),super.GetThisNormal(index*2+1));
63 } else {
64 return PBJ._PBJ.CastNormal();
65 }
66 }
67 public const int ImpulseFieldTag=6;
68 public int ImpulseCount { get { return super.ImpulseCount;} }
69 public bool HasImpulse(int index) {return PBJ._PBJ.ValidateFloat(super.GetImpulse(index));}
70 public float Impulse(int index) {
71 return (float)PBJ._PBJ.CastFloat(super.GetImpulse(index));
72 }
73 public const int OtherObjectReferenceFieldTag=7;
74 public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} }
75 public PBJ.UUID OtherObjectReference{ get {
76 if (HasOtherObjectReference) {
77 return PBJ._PBJ.CastUuid(super.OtherObjectReference);
78 } else {
79 return PBJ._PBJ.CastUuid();
80 }
81 }
82 }
83 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
84 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
85 public static Builder CreateBuilder() { return new Builder(); }
86 public static Builder CreateBuilder(CollisionBegin prototype) {
87 return (Builder)new Builder().MergeFrom(prototype);
88 }
89 public static CollisionBegin ParseFrom(pb::ByteString data) {
90 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data));
91 }
92 public static CollisionBegin ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
93 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er));
94 }
95 public static CollisionBegin ParseFrom(byte[] data) {
96 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data));
97 }
98 public static CollisionBegin ParseFrom(byte[] data, pb::ExtensionRegistry er) {
99 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er));
100 }
101 public static CollisionBegin ParseFrom(global::System.IO.Stream data) {
102 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data));
103 }
104 public static CollisionBegin ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
105 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er));
106 }
107 public static CollisionBegin ParseFrom(pb::CodedInputStream data) {
108 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data));
109 }
110 public static CollisionBegin ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
111 return new CollisionBegin(_PBJ_Internal.CollisionBegin.ParseFrom(data,er));
112 }
113 protected override bool _HasAllPBJFields{ get {
114 return true
115 ;
116 } }
117 public bool IsInitialized { get {
118 return super.IsInitialized&&_HasAllPBJFields;
119 } }
120 public class Builder : global::PBJ.IMessage.IBuilder{
121 protected override bool _HasAllPBJFields{ get {
122 return true
123 ;
124 } }
125 public bool IsInitialized { get {
126 return super.IsInitialized&&_HasAllPBJFields;
127 } }
128 protected _PBJ_Internal.CollisionBegin.Builder super;
129 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
130 public _PBJ_Internal.CollisionBegin.Builder _PBJSuper{ get { return super;} }
131 public Builder() {super = new _PBJ_Internal.CollisionBegin.Builder();}
132 public Builder(_PBJ_Internal.CollisionBegin.Builder other) {
133 super=other;
134 }
135 public Builder Clone() {return new Builder(super.Clone());}
136 public Builder MergeFrom(CollisionBegin prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
137 public Builder Clear() {super.Clear();return this;}
138 public CollisionBegin BuildPartial() {return new CollisionBegin(super.BuildPartial());}
139 public CollisionBegin Build() {if (_HasAllPBJFields) return new CollisionBegin(super.Build());return null;}
140 public pbd::MessageDescriptor DescriptorForType {
141 get { return CollisionBegin.Descriptor; } }
142 public Builder ClearTimestamp() { super.ClearTimestamp();return this;}
143 public const int TimestampFieldTag=2;
144 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
145 public PBJ.Time Timestamp{ get {
146 if (HasTimestamp) {
147 return PBJ._PBJ.CastTime(super.Timestamp);
148 } else {
149 return PBJ._PBJ.CastTime();
150 }
151 }
152 set {
153 super.Timestamp=(PBJ._PBJ.Construct(value));
154 }
155 }
156 public Builder ClearThisPosition() { super.ClearThisPosition();return this;}
157 public const int ThisPositionFieldTag=3;
158 public int ThisPositionCount { get { return super.ThisPositionCount/3;} }
159 public bool HasThisPosition(int index) { return true; }
160 public PBJ.Vector3d GetThisPosition(int index) {
161 if (HasThisPosition(index)) {
162 return PBJ._PBJ.CastVector3d(super.GetThisPosition(index*3+0),super.GetThisPosition(index*3+1),super.GetThisPosition(index*3+2));
163 } else {
164 return PBJ._PBJ.CastVector3d();
165 }
166 }
167 public Builder AddThisPosition(PBJ.Vector3d value) {
168 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
169 super.AddThisPosition(_PBJtempArray[0]);
170 super.AddThisPosition(_PBJtempArray[1]);
171 super.AddThisPosition(_PBJtempArray[2]);
172 return this;
173 }
174 public Builder SetThisPosition(int index,PBJ.Vector3d value) {
175 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
176 super.SetThisPosition(index*3+0,_PBJtempArray[0]);
177 super.SetThisPosition(index*3+1,_PBJtempArray[1]);
178 super.SetThisPosition(index*3+2,_PBJtempArray[2]);
179 return this;
180 }
181 public Builder ClearOtherPosition() { super.ClearOtherPosition();return this;}
182 public const int OtherPositionFieldTag=4;
183 public int OtherPositionCount { get { return super.OtherPositionCount/3;} }
184 public bool HasOtherPosition(int index) { return true; }
185 public PBJ.Vector3d GetOtherPosition(int index) {
186 if (HasOtherPosition(index)) {
187 return PBJ._PBJ.CastVector3d(super.GetOtherPosition(index*3+0),super.GetOtherPosition(index*3+1),super.GetOtherPosition(index*3+2));
188 } else {
189 return PBJ._PBJ.CastVector3d();
190 }
191 }
192 public Builder AddOtherPosition(PBJ.Vector3d value) {
193 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
194 super.AddOtherPosition(_PBJtempArray[0]);
195 super.AddOtherPosition(_PBJtempArray[1]);
196 super.AddOtherPosition(_PBJtempArray[2]);
197 return this;
198 }
199 public Builder SetOtherPosition(int index,PBJ.Vector3d value) {
200 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
201 super.SetOtherPosition(index*3+0,_PBJtempArray[0]);
202 super.SetOtherPosition(index*3+1,_PBJtempArray[1]);
203 super.SetOtherPosition(index*3+2,_PBJtempArray[2]);
204 return this;
205 }
206 public Builder ClearThisNormal() { super.ClearThisNormal();return this;}
207 public const int ThisNormalFieldTag=5;
208 public int ThisNormalCount { get { return super.ThisNormalCount/2;} }
209 public bool HasThisNormal(int index) { return true; }
210 public PBJ.Vector3f GetThisNormal(int index) {
211 if (HasThisNormal(index)) {
212 return PBJ._PBJ.CastNormal(super.GetThisNormal(index*2+0),super.GetThisNormal(index*2+1));
213 } else {
214 return PBJ._PBJ.CastNormal();
215 }
216 }
217 public Builder AddThisNormal(PBJ.Vector3f value) {
218 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
219 super.AddThisNormal(_PBJtempArray[0]);
220 super.AddThisNormal(_PBJtempArray[1]);
221 return this;
222 }
223 public Builder SetThisNormal(int index,PBJ.Vector3f value) {
224 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
225 super.SetThisNormal(index*2+0,_PBJtempArray[0]);
226 super.SetThisNormal(index*2+1,_PBJtempArray[1]);
227 return this;
228 }
229 public Builder ClearImpulse() { super.ClearImpulse();return this;}
230 public Builder SetImpulse(int index, float value) {
231 super.SetImpulse(index,PBJ._PBJ.Construct(value));
232 return this;
233 }
234 public const int ImpulseFieldTag=6;
235 public int ImpulseCount { get { return super.ImpulseCount;} }
236 public bool HasImpulse(int index) {return PBJ._PBJ.ValidateFloat(super.GetImpulse(index));}
237 public float Impulse(int index) {
238 return (float)PBJ._PBJ.CastFloat(super.GetImpulse(index));
239 }
240 public Builder AddImpulse(float value) {
241 super.AddImpulse(PBJ._PBJ.Construct(value));
242 return this;
243 }
244 public Builder ClearOtherObjectReference() { super.ClearOtherObjectReference();return this;}
245 public const int OtherObjectReferenceFieldTag=7;
246 public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} }
247 public PBJ.UUID OtherObjectReference{ get {
248 if (HasOtherObjectReference) {
249 return PBJ._PBJ.CastUuid(super.OtherObjectReference);
250 } else {
251 return PBJ._PBJ.CastUuid();
252 }
253 }
254 set {
255 super.OtherObjectReference=(PBJ._PBJ.Construct(value));
256 }
257 }
258 }
259 }
260}
261namespace Sirikata.Physics.Protocol {
262 public class CollisionEnd : PBJ.IMessage {
263 protected _PBJ_Internal.CollisionEnd super;
264 public _PBJ_Internal.CollisionEnd _PBJSuper{ get { return super;} }
265 public CollisionEnd() {
266 super=new _PBJ_Internal.CollisionEnd();
267 }
268 public CollisionEnd(_PBJ_Internal.CollisionEnd reference) {
269 super=reference;
270 }
271 public static CollisionEnd defaultInstance= new CollisionEnd (_PBJ_Internal.CollisionEnd.DefaultInstance);
272 public static CollisionEnd DefaultInstance{
273 get {return defaultInstance;}
274 }
275 public static pbd.MessageDescriptor Descriptor {
276 get { return _PBJ_Internal.CollisionEnd.Descriptor; } }
277 public static class Types {
278 }
279 public static bool WithinReservedFieldTagRange(int field_tag) {
280 return false;
281 }
282 public static bool WithinExtensionFieldTagRange(int field_tag) {
283 return false;
284 }
285 public const int TimestampFieldTag=2;
286 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
287 public PBJ.Time Timestamp{ get {
288 if (HasTimestamp) {
289 return PBJ._PBJ.CastTime(super.Timestamp);
290 } else {
291 return PBJ._PBJ.CastTime();
292 }
293 }
294 }
295 public const int OtherObjectReferenceFieldTag=6;
296 public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} }
297 public PBJ.UUID OtherObjectReference{ get {
298 if (HasOtherObjectReference) {
299 return PBJ._PBJ.CastUuid(super.OtherObjectReference);
300 } else {
301 return PBJ._PBJ.CastUuid();
302 }
303 }
304 }
305 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
306 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
307 public static Builder CreateBuilder() { return new Builder(); }
308 public static Builder CreateBuilder(CollisionEnd prototype) {
309 return (Builder)new Builder().MergeFrom(prototype);
310 }
311 public static CollisionEnd ParseFrom(pb::ByteString data) {
312 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data));
313 }
314 public static CollisionEnd ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
315 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er));
316 }
317 public static CollisionEnd ParseFrom(byte[] data) {
318 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data));
319 }
320 public static CollisionEnd ParseFrom(byte[] data, pb::ExtensionRegistry er) {
321 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er));
322 }
323 public static CollisionEnd ParseFrom(global::System.IO.Stream data) {
324 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data));
325 }
326 public static CollisionEnd ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
327 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er));
328 }
329 public static CollisionEnd ParseFrom(pb::CodedInputStream data) {
330 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data));
331 }
332 public static CollisionEnd ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
333 return new CollisionEnd(_PBJ_Internal.CollisionEnd.ParseFrom(data,er));
334 }
335 protected override bool _HasAllPBJFields{ get {
336 return true
337 ;
338 } }
339 public bool IsInitialized { get {
340 return super.IsInitialized&&_HasAllPBJFields;
341 } }
342 public class Builder : global::PBJ.IMessage.IBuilder{
343 protected override bool _HasAllPBJFields{ get {
344 return true
345 ;
346 } }
347 public bool IsInitialized { get {
348 return super.IsInitialized&&_HasAllPBJFields;
349 } }
350 protected _PBJ_Internal.CollisionEnd.Builder super;
351 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
352 public _PBJ_Internal.CollisionEnd.Builder _PBJSuper{ get { return super;} }
353 public Builder() {super = new _PBJ_Internal.CollisionEnd.Builder();}
354 public Builder(_PBJ_Internal.CollisionEnd.Builder other) {
355 super=other;
356 }
357 public Builder Clone() {return new Builder(super.Clone());}
358 public Builder MergeFrom(CollisionEnd prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
359 public Builder Clear() {super.Clear();return this;}
360 public CollisionEnd BuildPartial() {return new CollisionEnd(super.BuildPartial());}
361 public CollisionEnd Build() {if (_HasAllPBJFields) return new CollisionEnd(super.Build());return null;}
362 public pbd::MessageDescriptor DescriptorForType {
363 get { return CollisionEnd.Descriptor; } }
364 public Builder ClearTimestamp() { super.ClearTimestamp();return this;}
365 public const int TimestampFieldTag=2;
366 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
367 public PBJ.Time Timestamp{ get {
368 if (HasTimestamp) {
369 return PBJ._PBJ.CastTime(super.Timestamp);
370 } else {
371 return PBJ._PBJ.CastTime();
372 }
373 }
374 set {
375 super.Timestamp=(PBJ._PBJ.Construct(value));
376 }
377 }
378 public Builder ClearOtherObjectReference() { super.ClearOtherObjectReference();return this;}
379 public const int OtherObjectReferenceFieldTag=6;
380 public bool HasOtherObjectReference{ get {return super.HasOtherObjectReference&&PBJ._PBJ.ValidateUuid(super.OtherObjectReference);} }
381 public PBJ.UUID OtherObjectReference{ get {
382 if (HasOtherObjectReference) {
383 return PBJ._PBJ.CastUuid(super.OtherObjectReference);
384 } else {
385 return PBJ._PBJ.CastUuid();
386 }
387 }
388 set {
389 super.OtherObjectReference=(PBJ._PBJ.Construct(value));
390 }
391 }
392 }
393 }
394}
diff --git a/OpenSim/Client/Sirikata/Protocol/Sirikata.cs b/OpenSim/Client/Sirikata/Protocol/Sirikata.cs
new file mode 100644
index 0000000..9283086
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Sirikata.cs
@@ -0,0 +1,8074 @@
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2
3using pb = global::Google.ProtocolBuffers;
4using pbc = global::Google.ProtocolBuffers.Collections;
5using pbd = global::Google.ProtocolBuffers.Descriptors;
6using scg = global::System.Collections.Generic;
7namespace 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
new file mode 100644
index 0000000..9c0e3e7
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs
@@ -0,0 +1,3907 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.Protocol {
4 public class MessageBody : PBJ.IMessage {
5 protected _PBJ_Internal.MessageBody super;
6 public _PBJ_Internal.MessageBody _PBJSuper{ get { return super;} }
7 public MessageBody() {
8 super=new _PBJ_Internal.MessageBody();
9 }
10 public MessageBody(_PBJ_Internal.MessageBody reference) {
11 super=reference;
12 }
13 public static MessageBody defaultInstance= new MessageBody (_PBJ_Internal.MessageBody.DefaultInstance);
14 public static MessageBody DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.MessageBody.Descriptor; } }
19 public static class Types {
20 }
21 public static bool WithinReservedFieldTagRange(int field_tag) {
22 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
23 }
24 public static bool WithinExtensionFieldTagRange(int field_tag) {
25 return false;
26 }
27 public const int MessageNamesFieldTag=9;
28 public int MessageNamesCount { get { return super.MessageNamesCount;} }
29 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
30 public string MessageNames(int index) {
31 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
32 }
33 public const int MessageArgumentsFieldTag=10;
34 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
35 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
36 public pb::ByteString MessageArguments(int index) {
37 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
38 }
39 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
40 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
41 public static Builder CreateBuilder() { return new Builder(); }
42 public static Builder CreateBuilder(MessageBody prototype) {
43 return (Builder)new Builder().MergeFrom(prototype);
44 }
45 public static MessageBody ParseFrom(pb::ByteString data) {
46 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
47 }
48 public static MessageBody ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
49 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
50 }
51 public static MessageBody ParseFrom(byte[] data) {
52 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
53 }
54 public static MessageBody ParseFrom(byte[] data, pb::ExtensionRegistry er) {
55 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
56 }
57 public static MessageBody ParseFrom(global::System.IO.Stream data) {
58 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
59 }
60 public static MessageBody ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
61 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
62 }
63 public static MessageBody ParseFrom(pb::CodedInputStream data) {
64 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
65 }
66 public static MessageBody ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
67 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
68 }
69 protected override bool _HasAllPBJFields{ get {
70 return true
71 ;
72 } }
73 public bool IsInitialized { get {
74 return super.IsInitialized&&_HasAllPBJFields;
75 } }
76 public class Builder : global::PBJ.IMessage.IBuilder{
77 protected override bool _HasAllPBJFields{ get {
78 return true
79 ;
80 } }
81 public bool IsInitialized { get {
82 return super.IsInitialized&&_HasAllPBJFields;
83 } }
84 protected _PBJ_Internal.MessageBody.Builder super;
85 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
86 public _PBJ_Internal.MessageBody.Builder _PBJSuper{ get { return super;} }
87 public Builder() {super = new _PBJ_Internal.MessageBody.Builder();}
88 public Builder(_PBJ_Internal.MessageBody.Builder other) {
89 super=other;
90 }
91 public Builder Clone() {return new Builder(super.Clone());}
92 public Builder MergeFrom(MessageBody prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
93 public Builder Clear() {super.Clear();return this;}
94 public MessageBody BuildPartial() {return new MessageBody(super.BuildPartial());}
95 public MessageBody Build() {if (_HasAllPBJFields) return new MessageBody(super.Build());return null;}
96 public pbd::MessageDescriptor DescriptorForType {
97 get { return MessageBody.Descriptor; } }
98 public Builder ClearMessageNames() { super.ClearMessageNames();return this;}
99 public Builder SetMessageNames(int index, string value) {
100 super.SetMessageNames(index,PBJ._PBJ.Construct(value));
101 return this;
102 }
103 public const int MessageNamesFieldTag=9;
104 public int MessageNamesCount { get { return super.MessageNamesCount;} }
105 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
106 public string MessageNames(int index) {
107 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
108 }
109 public Builder AddMessageNames(string value) {
110 super.AddMessageNames(PBJ._PBJ.Construct(value));
111 return this;
112 }
113 public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;}
114 public Builder SetMessageArguments(int index, pb::ByteString value) {
115 super.SetMessageArguments(index,PBJ._PBJ.Construct(value));
116 return this;
117 }
118 public const int MessageArgumentsFieldTag=10;
119 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
120 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
121 public pb::ByteString MessageArguments(int index) {
122 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
123 }
124 public Builder AddMessageArguments(pb::ByteString value) {
125 super.AddMessageArguments(PBJ._PBJ.Construct(value));
126 return this;
127 }
128 }
129 }
130}
131namespace Sirikata.Protocol {
132 public class ReadOnlyMessage : PBJ.IMessage {
133 protected _PBJ_Internal.ReadOnlyMessage super;
134 public _PBJ_Internal.ReadOnlyMessage _PBJSuper{ get { return super;} }
135 public ReadOnlyMessage() {
136 super=new _PBJ_Internal.ReadOnlyMessage();
137 }
138 public ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage reference) {
139 super=reference;
140 }
141 public static ReadOnlyMessage defaultInstance= new ReadOnlyMessage (_PBJ_Internal.ReadOnlyMessage.DefaultInstance);
142 public static ReadOnlyMessage DefaultInstance{
143 get {return defaultInstance;}
144 }
145 public static pbd.MessageDescriptor Descriptor {
146 get { return _PBJ_Internal.ReadOnlyMessage.Descriptor; } }
147 public static class Types {
148 public enum ReturnStatus {
149 SUCCESS=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS,
150 NETWORK_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.NETWORK_FAILURE,
151 TIMEOUT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.TIMEOUT_FAILURE,
152 PROTOCOL_ERROR=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PROTOCOL_ERROR,
153 PORT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PORT_FAILURE
154 };
155 }
156 public static bool WithinReservedFieldTagRange(int field_tag) {
157 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
158 }
159 public static bool WithinExtensionFieldTagRange(int field_tag) {
160 return false;
161 }
162 public const int SourceObjectFieldTag=1;
163 public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} }
164 public PBJ.UUID SourceObject{ get {
165 if (HasSourceObject) {
166 return PBJ._PBJ.CastUuid(super.SourceObject);
167 } else {
168 return PBJ._PBJ.CastUuid();
169 }
170 }
171 }
172 public const int SourcePortFieldTag=3;
173 public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} }
174 public uint SourcePort{ get {
175 if (HasSourcePort) {
176 return PBJ._PBJ.CastUint32(super.SourcePort);
177 } else {
178 return PBJ._PBJ.CastUint32();
179 }
180 }
181 }
182 public const int SourceSpaceFieldTag=1536;
183 public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} }
184 public PBJ.UUID SourceSpace{ get {
185 if (HasSourceSpace) {
186 return PBJ._PBJ.CastUuid(super.SourceSpace);
187 } else {
188 return PBJ._PBJ.CastUuid();
189 }
190 }
191 }
192 public const int DestinationObjectFieldTag=2;
193 public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} }
194 public PBJ.UUID DestinationObject{ get {
195 if (HasDestinationObject) {
196 return PBJ._PBJ.CastUuid(super.DestinationObject);
197 } else {
198 return PBJ._PBJ.CastUuid();
199 }
200 }
201 }
202 public const int DestinationPortFieldTag=4;
203 public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} }
204 public uint DestinationPort{ get {
205 if (HasDestinationPort) {
206 return PBJ._PBJ.CastUint32(super.DestinationPort);
207 } else {
208 return PBJ._PBJ.CastUint32();
209 }
210 }
211 }
212 public const int DestinationSpaceFieldTag=1537;
213 public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} }
214 public PBJ.UUID DestinationSpace{ get {
215 if (HasDestinationSpace) {
216 return PBJ._PBJ.CastUuid(super.DestinationSpace);
217 } else {
218 return PBJ._PBJ.CastUuid();
219 }
220 }
221 }
222 public const int IdFieldTag=7;
223 public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} }
224 public long Id{ get {
225 if (HasId) {
226 return PBJ._PBJ.CastInt64(super.Id);
227 } else {
228 return PBJ._PBJ.CastInt64();
229 }
230 }
231 }
232 public const int ReplyIdFieldTag=8;
233 public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} }
234 public long ReplyId{ get {
235 if (HasReplyId) {
236 return PBJ._PBJ.CastInt64(super.ReplyId);
237 } else {
238 return PBJ._PBJ.CastInt64();
239 }
240 }
241 }
242 public const int ReturnStatusFieldTag=1792;
243 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
244 public Types.ReturnStatus ReturnStatus{ get {
245 if (HasReturnStatus) {
246 return (Types.ReturnStatus)super.ReturnStatus;
247 } else {
248 return new Types.ReturnStatus();
249 }
250 }
251 }
252 public const int MessageNamesFieldTag=9;
253 public int MessageNamesCount { get { return super.MessageNamesCount;} }
254 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
255 public string MessageNames(int index) {
256 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
257 }
258 public const int MessageArgumentsFieldTag=10;
259 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
260 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
261 public pb::ByteString MessageArguments(int index) {
262 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
263 }
264 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
265 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
266 public static Builder CreateBuilder() { return new Builder(); }
267 public static Builder CreateBuilder(ReadOnlyMessage prototype) {
268 return (Builder)new Builder().MergeFrom(prototype);
269 }
270 public static ReadOnlyMessage ParseFrom(pb::ByteString data) {
271 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
272 }
273 public static ReadOnlyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
274 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
275 }
276 public static ReadOnlyMessage ParseFrom(byte[] data) {
277 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
278 }
279 public static ReadOnlyMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
280 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
281 }
282 public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data) {
283 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
284 }
285 public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
286 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
287 }
288 public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data) {
289 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
290 }
291 public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
292 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
293 }
294 protected override bool _HasAllPBJFields{ get {
295 return true
296 ;
297 } }
298 public bool IsInitialized { get {
299 return super.IsInitialized&&_HasAllPBJFields;
300 } }
301 public class Builder : global::PBJ.IMessage.IBuilder{
302 protected override bool _HasAllPBJFields{ get {
303 return true
304 ;
305 } }
306 public bool IsInitialized { get {
307 return super.IsInitialized&&_HasAllPBJFields;
308 } }
309 protected _PBJ_Internal.ReadOnlyMessage.Builder super;
310 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
311 public _PBJ_Internal.ReadOnlyMessage.Builder _PBJSuper{ get { return super;} }
312 public Builder() {super = new _PBJ_Internal.ReadOnlyMessage.Builder();}
313 public Builder(_PBJ_Internal.ReadOnlyMessage.Builder other) {
314 super=other;
315 }
316 public Builder Clone() {return new Builder(super.Clone());}
317 public Builder MergeFrom(ReadOnlyMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
318 public Builder Clear() {super.Clear();return this;}
319 public ReadOnlyMessage BuildPartial() {return new ReadOnlyMessage(super.BuildPartial());}
320 public ReadOnlyMessage Build() {if (_HasAllPBJFields) return new ReadOnlyMessage(super.Build());return null;}
321 public pbd::MessageDescriptor DescriptorForType {
322 get { return ReadOnlyMessage.Descriptor; } }
323 public Builder ClearSourceObject() { super.ClearSourceObject();return this;}
324 public const int SourceObjectFieldTag=1;
325 public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} }
326 public PBJ.UUID SourceObject{ get {
327 if (HasSourceObject) {
328 return PBJ._PBJ.CastUuid(super.SourceObject);
329 } else {
330 return PBJ._PBJ.CastUuid();
331 }
332 }
333 set {
334 super.SourceObject=(PBJ._PBJ.Construct(value));
335 }
336 }
337 public Builder ClearSourcePort() { super.ClearSourcePort();return this;}
338 public const int SourcePortFieldTag=3;
339 public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} }
340 public uint SourcePort{ get {
341 if (HasSourcePort) {
342 return PBJ._PBJ.CastUint32(super.SourcePort);
343 } else {
344 return PBJ._PBJ.CastUint32();
345 }
346 }
347 set {
348 super.SourcePort=(PBJ._PBJ.Construct(value));
349 }
350 }
351 public Builder ClearSourceSpace() { super.ClearSourceSpace();return this;}
352 public const int SourceSpaceFieldTag=1536;
353 public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} }
354 public PBJ.UUID SourceSpace{ get {
355 if (HasSourceSpace) {
356 return PBJ._PBJ.CastUuid(super.SourceSpace);
357 } else {
358 return PBJ._PBJ.CastUuid();
359 }
360 }
361 set {
362 super.SourceSpace=(PBJ._PBJ.Construct(value));
363 }
364 }
365 public Builder ClearDestinationObject() { super.ClearDestinationObject();return this;}
366 public const int DestinationObjectFieldTag=2;
367 public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} }
368 public PBJ.UUID DestinationObject{ get {
369 if (HasDestinationObject) {
370 return PBJ._PBJ.CastUuid(super.DestinationObject);
371 } else {
372 return PBJ._PBJ.CastUuid();
373 }
374 }
375 set {
376 super.DestinationObject=(PBJ._PBJ.Construct(value));
377 }
378 }
379 public Builder ClearDestinationPort() { super.ClearDestinationPort();return this;}
380 public const int DestinationPortFieldTag=4;
381 public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} }
382 public uint DestinationPort{ get {
383 if (HasDestinationPort) {
384 return PBJ._PBJ.CastUint32(super.DestinationPort);
385 } else {
386 return PBJ._PBJ.CastUint32();
387 }
388 }
389 set {
390 super.DestinationPort=(PBJ._PBJ.Construct(value));
391 }
392 }
393 public Builder ClearDestinationSpace() { super.ClearDestinationSpace();return this;}
394 public const int DestinationSpaceFieldTag=1537;
395 public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} }
396 public PBJ.UUID DestinationSpace{ get {
397 if (HasDestinationSpace) {
398 return PBJ._PBJ.CastUuid(super.DestinationSpace);
399 } else {
400 return PBJ._PBJ.CastUuid();
401 }
402 }
403 set {
404 super.DestinationSpace=(PBJ._PBJ.Construct(value));
405 }
406 }
407 public Builder ClearId() { super.ClearId();return this;}
408 public const int IdFieldTag=7;
409 public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} }
410 public long Id{ get {
411 if (HasId) {
412 return PBJ._PBJ.CastInt64(super.Id);
413 } else {
414 return PBJ._PBJ.CastInt64();
415 }
416 }
417 set {
418 super.Id=(PBJ._PBJ.Construct(value));
419 }
420 }
421 public Builder ClearReplyId() { super.ClearReplyId();return this;}
422 public const int ReplyIdFieldTag=8;
423 public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} }
424 public long ReplyId{ get {
425 if (HasReplyId) {
426 return PBJ._PBJ.CastInt64(super.ReplyId);
427 } else {
428 return PBJ._PBJ.CastInt64();
429 }
430 }
431 set {
432 super.ReplyId=(PBJ._PBJ.Construct(value));
433 }
434 }
435 public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;}
436 public const int ReturnStatusFieldTag=1792;
437 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
438 public Types.ReturnStatus ReturnStatus{ get {
439 if (HasReturnStatus) {
440 return (Types.ReturnStatus)super.ReturnStatus;
441 } else {
442 return new Types.ReturnStatus();
443 }
444 }
445 set {
446 super.ReturnStatus=((_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus)value);
447 }
448 }
449 public Builder ClearMessageNames() { super.ClearMessageNames();return this;}
450 public Builder SetMessageNames(int index, string value) {
451 super.SetMessageNames(index,PBJ._PBJ.Construct(value));
452 return this;
453 }
454 public const int MessageNamesFieldTag=9;
455 public int MessageNamesCount { get { return super.MessageNamesCount;} }
456 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
457 public string MessageNames(int index) {
458 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
459 }
460 public Builder AddMessageNames(string value) {
461 super.AddMessageNames(PBJ._PBJ.Construct(value));
462 return this;
463 }
464 public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;}
465 public Builder SetMessageArguments(int index, pb::ByteString value) {
466 super.SetMessageArguments(index,PBJ._PBJ.Construct(value));
467 return this;
468 }
469 public const int MessageArgumentsFieldTag=10;
470 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
471 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
472 public pb::ByteString MessageArguments(int index) {
473 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
474 }
475 public Builder AddMessageArguments(pb::ByteString value) {
476 super.AddMessageArguments(PBJ._PBJ.Construct(value));
477 return this;
478 }
479 }
480 }
481}
482namespace Sirikata.Protocol {
483 public class SpaceServices : PBJ.IMessage {
484 protected _PBJ_Internal.SpaceServices super;
485 public _PBJ_Internal.SpaceServices _PBJSuper{ get { return super;} }
486 public SpaceServices() {
487 super=new _PBJ_Internal.SpaceServices();
488 }
489 public SpaceServices(_PBJ_Internal.SpaceServices reference) {
490 super=reference;
491 }
492 public static SpaceServices defaultInstance= new SpaceServices (_PBJ_Internal.SpaceServices.DefaultInstance);
493 public static SpaceServices DefaultInstance{
494 get {return defaultInstance;}
495 }
496 public static pbd.MessageDescriptor Descriptor {
497 get { return _PBJ_Internal.SpaceServices.Descriptor; } }
498 public static class Types {
499 }
500 public static bool WithinReservedFieldTagRange(int field_tag) {
501 return false;
502 }
503 public static bool WithinExtensionFieldTagRange(int field_tag) {
504 return false;
505 }
506 public const int RegistrationPortFieldTag=33;
507 public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} }
508 public uint RegistrationPort{ get {
509 if (HasRegistrationPort) {
510 return PBJ._PBJ.CastUint32(super.RegistrationPort);
511 } else {
512 return PBJ._PBJ.CastUint32();
513 }
514 }
515 }
516 public const int LocPortFieldTag=34;
517 public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} }
518 public uint LocPort{ get {
519 if (HasLocPort) {
520 return PBJ._PBJ.CastUint32(super.LocPort);
521 } else {
522 return PBJ._PBJ.CastUint32();
523 }
524 }
525 }
526 public const int GeomPortFieldTag=35;
527 public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} }
528 public uint GeomPort{ get {
529 if (HasGeomPort) {
530 return PBJ._PBJ.CastUint32(super.GeomPort);
531 } else {
532 return PBJ._PBJ.CastUint32();
533 }
534 }
535 }
536 public const int OsegPortFieldTag=36;
537 public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} }
538 public uint OsegPort{ get {
539 if (HasOsegPort) {
540 return PBJ._PBJ.CastUint32(super.OsegPort);
541 } else {
542 return PBJ._PBJ.CastUint32();
543 }
544 }
545 }
546 public const int CsegPortFieldTag=37;
547 public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} }
548 public uint CsegPort{ get {
549 if (HasCsegPort) {
550 return PBJ._PBJ.CastUint32(super.CsegPort);
551 } else {
552 return PBJ._PBJ.CastUint32();
553 }
554 }
555 }
556 public const int RouterPortFieldTag=38;
557 public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} }
558 public uint RouterPort{ get {
559 if (HasRouterPort) {
560 return PBJ._PBJ.CastUint32(super.RouterPort);
561 } else {
562 return PBJ._PBJ.CastUint32();
563 }
564 }
565 }
566 public const int PreConnectionBufferFieldTag=64;
567 public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} }
568 public ulong PreConnectionBuffer{ get {
569 if (HasPreConnectionBuffer) {
570 return PBJ._PBJ.CastUint64(super.PreConnectionBuffer);
571 } else {
572 return PBJ._PBJ.CastUint64();
573 }
574 }
575 }
576 public const int MaxPreConnectionMessagesFieldTag=65;
577 public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} }
578 public ulong MaxPreConnectionMessages{ get {
579 if (HasMaxPreConnectionMessages) {
580 return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages);
581 } else {
582 return PBJ._PBJ.CastUint64();
583 }
584 }
585 }
586 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
587 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
588 public static Builder CreateBuilder() { return new Builder(); }
589 public static Builder CreateBuilder(SpaceServices prototype) {
590 return (Builder)new Builder().MergeFrom(prototype);
591 }
592 public static SpaceServices ParseFrom(pb::ByteString data) {
593 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
594 }
595 public static SpaceServices ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
596 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
597 }
598 public static SpaceServices ParseFrom(byte[] data) {
599 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
600 }
601 public static SpaceServices ParseFrom(byte[] data, pb::ExtensionRegistry er) {
602 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
603 }
604 public static SpaceServices ParseFrom(global::System.IO.Stream data) {
605 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
606 }
607 public static SpaceServices ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
608 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
609 }
610 public static SpaceServices ParseFrom(pb::CodedInputStream data) {
611 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
612 }
613 public static SpaceServices ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
614 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
615 }
616 protected override bool _HasAllPBJFields{ get {
617 return true
618 ;
619 } }
620 public bool IsInitialized { get {
621 return super.IsInitialized&&_HasAllPBJFields;
622 } }
623 public class Builder : global::PBJ.IMessage.IBuilder{
624 protected override bool _HasAllPBJFields{ get {
625 return true
626 ;
627 } }
628 public bool IsInitialized { get {
629 return super.IsInitialized&&_HasAllPBJFields;
630 } }
631 protected _PBJ_Internal.SpaceServices.Builder super;
632 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
633 public _PBJ_Internal.SpaceServices.Builder _PBJSuper{ get { return super;} }
634 public Builder() {super = new _PBJ_Internal.SpaceServices.Builder();}
635 public Builder(_PBJ_Internal.SpaceServices.Builder other) {
636 super=other;
637 }
638 public Builder Clone() {return new Builder(super.Clone());}
639 public Builder MergeFrom(SpaceServices prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
640 public Builder Clear() {super.Clear();return this;}
641 public SpaceServices BuildPartial() {return new SpaceServices(super.BuildPartial());}
642 public SpaceServices Build() {if (_HasAllPBJFields) return new SpaceServices(super.Build());return null;}
643 public pbd::MessageDescriptor DescriptorForType {
644 get { return SpaceServices.Descriptor; } }
645 public Builder ClearRegistrationPort() { super.ClearRegistrationPort();return this;}
646 public const int RegistrationPortFieldTag=33;
647 public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} }
648 public uint RegistrationPort{ get {
649 if (HasRegistrationPort) {
650 return PBJ._PBJ.CastUint32(super.RegistrationPort);
651 } else {
652 return PBJ._PBJ.CastUint32();
653 }
654 }
655 set {
656 super.RegistrationPort=(PBJ._PBJ.Construct(value));
657 }
658 }
659 public Builder ClearLocPort() { super.ClearLocPort();return this;}
660 public const int LocPortFieldTag=34;
661 public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} }
662 public uint LocPort{ get {
663 if (HasLocPort) {
664 return PBJ._PBJ.CastUint32(super.LocPort);
665 } else {
666 return PBJ._PBJ.CastUint32();
667 }
668 }
669 set {
670 super.LocPort=(PBJ._PBJ.Construct(value));
671 }
672 }
673 public Builder ClearGeomPort() { super.ClearGeomPort();return this;}
674 public const int GeomPortFieldTag=35;
675 public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} }
676 public uint GeomPort{ get {
677 if (HasGeomPort) {
678 return PBJ._PBJ.CastUint32(super.GeomPort);
679 } else {
680 return PBJ._PBJ.CastUint32();
681 }
682 }
683 set {
684 super.GeomPort=(PBJ._PBJ.Construct(value));
685 }
686 }
687 public Builder ClearOsegPort() { super.ClearOsegPort();return this;}
688 public const int OsegPortFieldTag=36;
689 public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} }
690 public uint OsegPort{ get {
691 if (HasOsegPort) {
692 return PBJ._PBJ.CastUint32(super.OsegPort);
693 } else {
694 return PBJ._PBJ.CastUint32();
695 }
696 }
697 set {
698 super.OsegPort=(PBJ._PBJ.Construct(value));
699 }
700 }
701 public Builder ClearCsegPort() { super.ClearCsegPort();return this;}
702 public const int CsegPortFieldTag=37;
703 public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} }
704 public uint CsegPort{ get {
705 if (HasCsegPort) {
706 return PBJ._PBJ.CastUint32(super.CsegPort);
707 } else {
708 return PBJ._PBJ.CastUint32();
709 }
710 }
711 set {
712 super.CsegPort=(PBJ._PBJ.Construct(value));
713 }
714 }
715 public Builder ClearRouterPort() { super.ClearRouterPort();return this;}
716 public const int RouterPortFieldTag=38;
717 public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} }
718 public uint RouterPort{ get {
719 if (HasRouterPort) {
720 return PBJ._PBJ.CastUint32(super.RouterPort);
721 } else {
722 return PBJ._PBJ.CastUint32();
723 }
724 }
725 set {
726 super.RouterPort=(PBJ._PBJ.Construct(value));
727 }
728 }
729 public Builder ClearPreConnectionBuffer() { super.ClearPreConnectionBuffer();return this;}
730 public const int PreConnectionBufferFieldTag=64;
731 public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} }
732 public ulong PreConnectionBuffer{ get {
733 if (HasPreConnectionBuffer) {
734 return PBJ._PBJ.CastUint64(super.PreConnectionBuffer);
735 } else {
736 return PBJ._PBJ.CastUint64();
737 }
738 }
739 set {
740 super.PreConnectionBuffer=(PBJ._PBJ.Construct(value));
741 }
742 }
743 public Builder ClearMaxPreConnectionMessages() { super.ClearMaxPreConnectionMessages();return this;}
744 public const int MaxPreConnectionMessagesFieldTag=65;
745 public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} }
746 public ulong MaxPreConnectionMessages{ get {
747 if (HasMaxPreConnectionMessages) {
748 return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages);
749 } else {
750 return PBJ._PBJ.CastUint64();
751 }
752 }
753 set {
754 super.MaxPreConnectionMessages=(PBJ._PBJ.Construct(value));
755 }
756 }
757 }
758 }
759}
760namespace Sirikata.Protocol {
761 public class ObjLoc : PBJ.IMessage {
762 protected _PBJ_Internal.ObjLoc super;
763 public _PBJ_Internal.ObjLoc _PBJSuper{ get { return super;} }
764 public ObjLoc() {
765 super=new _PBJ_Internal.ObjLoc();
766 }
767 public ObjLoc(_PBJ_Internal.ObjLoc reference) {
768 super=reference;
769 }
770 public static ObjLoc defaultInstance= new ObjLoc (_PBJ_Internal.ObjLoc.DefaultInstance);
771 public static ObjLoc DefaultInstance{
772 get {return defaultInstance;}
773 }
774 public static pbd.MessageDescriptor Descriptor {
775 get { return _PBJ_Internal.ObjLoc.Descriptor; } }
776 public static class Types {
777 public enum UpdateFlags {
778 FORCE=_PBJ_Internal.ObjLoc.Types.UpdateFlags.FORCE
779 };
780 }
781 public static bool WithinReservedFieldTagRange(int field_tag) {
782 return false;
783 }
784 public static bool WithinExtensionFieldTagRange(int field_tag) {
785 return false;
786 }
787 public const int TimestampFieldTag=2;
788 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
789 public PBJ.Time Timestamp{ get {
790 if (HasTimestamp) {
791 return PBJ._PBJ.CastTime(super.Timestamp);
792 } else {
793 return PBJ._PBJ.CastTime();
794 }
795 }
796 }
797 public const int PositionFieldTag=3;
798 public bool HasPosition{ get {return super.PositionCount>=3;} }
799 public PBJ.Vector3d Position{ get {
800 int index=0;
801 if (HasPosition) {
802 return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2));
803 } else {
804 return PBJ._PBJ.CastVector3d();
805 }
806 }
807 }
808 public const int OrientationFieldTag=4;
809 public bool HasOrientation{ get {return super.OrientationCount>=3;} }
810 public PBJ.Quaternion Orientation{ get {
811 int index=0;
812 if (HasOrientation) {
813 return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2));
814 } else {
815 return PBJ._PBJ.CastQuaternion();
816 }
817 }
818 }
819 public const int VelocityFieldTag=5;
820 public bool HasVelocity{ get {return super.VelocityCount>=3;} }
821 public PBJ.Vector3f Velocity{ get {
822 int index=0;
823 if (HasVelocity) {
824 return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2));
825 } else {
826 return PBJ._PBJ.CastVector3f();
827 }
828 }
829 }
830 public const int RotationalAxisFieldTag=7;
831 public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} }
832 public PBJ.Vector3f RotationalAxis{ get {
833 int index=0;
834 if (HasRotationalAxis) {
835 return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1));
836 } else {
837 return PBJ._PBJ.CastNormal();
838 }
839 }
840 }
841 public const int AngularSpeedFieldTag=8;
842 public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} }
843 public float AngularSpeed{ get {
844 if (HasAngularSpeed) {
845 return PBJ._PBJ.CastFloat(super.AngularSpeed);
846 } else {
847 return PBJ._PBJ.CastFloat();
848 }
849 }
850 }
851 public const int UpdateFlagsFieldTag=6;
852 public bool HasUpdateFlags { get {
853 if (!super.HasUpdateFlags) return false;
854 return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
855 } }
856 public byte UpdateFlags{ get {
857 if (HasUpdateFlags) {
858 return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
859 } else {
860 return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE);
861 }
862 }
863 }
864 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
865 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
866 public static Builder CreateBuilder() { return new Builder(); }
867 public static Builder CreateBuilder(ObjLoc prototype) {
868 return (Builder)new Builder().MergeFrom(prototype);
869 }
870 public static ObjLoc ParseFrom(pb::ByteString data) {
871 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
872 }
873 public static ObjLoc ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
874 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
875 }
876 public static ObjLoc ParseFrom(byte[] data) {
877 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
878 }
879 public static ObjLoc ParseFrom(byte[] data, pb::ExtensionRegistry er) {
880 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
881 }
882 public static ObjLoc ParseFrom(global::System.IO.Stream data) {
883 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
884 }
885 public static ObjLoc ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
886 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
887 }
888 public static ObjLoc ParseFrom(pb::CodedInputStream data) {
889 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
890 }
891 public static ObjLoc ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
892 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
893 }
894 protected override bool _HasAllPBJFields{ get {
895 return true
896 ;
897 } }
898 public bool IsInitialized { get {
899 return super.IsInitialized&&_HasAllPBJFields;
900 } }
901 public class Builder : global::PBJ.IMessage.IBuilder{
902 protected override bool _HasAllPBJFields{ get {
903 return true
904 ;
905 } }
906 public bool IsInitialized { get {
907 return super.IsInitialized&&_HasAllPBJFields;
908 } }
909 protected _PBJ_Internal.ObjLoc.Builder super;
910 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
911 public _PBJ_Internal.ObjLoc.Builder _PBJSuper{ get { return super;} }
912 public Builder() {super = new _PBJ_Internal.ObjLoc.Builder();}
913 public Builder(_PBJ_Internal.ObjLoc.Builder other) {
914 super=other;
915 }
916 public Builder Clone() {return new Builder(super.Clone());}
917 public Builder MergeFrom(ObjLoc prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
918 public Builder Clear() {super.Clear();return this;}
919 public ObjLoc BuildPartial() {return new ObjLoc(super.BuildPartial());}
920 public ObjLoc Build() {if (_HasAllPBJFields) return new ObjLoc(super.Build());return null;}
921 public pbd::MessageDescriptor DescriptorForType {
922 get { return ObjLoc.Descriptor; } }
923 public Builder ClearTimestamp() { super.ClearTimestamp();return this;}
924 public const int TimestampFieldTag=2;
925 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
926 public PBJ.Time Timestamp{ get {
927 if (HasTimestamp) {
928 return PBJ._PBJ.CastTime(super.Timestamp);
929 } else {
930 return PBJ._PBJ.CastTime();
931 }
932 }
933 set {
934 super.Timestamp=(PBJ._PBJ.Construct(value));
935 }
936 }
937 public Builder ClearPosition() { super.ClearPosition();return this;}
938 public const int PositionFieldTag=3;
939 public bool HasPosition{ get {return super.PositionCount>=3;} }
940 public PBJ.Vector3d Position{ get {
941 int index=0;
942 if (HasPosition) {
943 return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2));
944 } else {
945 return PBJ._PBJ.CastVector3d();
946 }
947 }
948 set {
949 super.ClearPosition();
950 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
951 super.AddPosition(_PBJtempArray[0]);
952 super.AddPosition(_PBJtempArray[1]);
953 super.AddPosition(_PBJtempArray[2]);
954 }
955 }
956 public Builder ClearOrientation() { super.ClearOrientation();return this;}
957 public const int OrientationFieldTag=4;
958 public bool HasOrientation{ get {return super.OrientationCount>=3;} }
959 public PBJ.Quaternion Orientation{ get {
960 int index=0;
961 if (HasOrientation) {
962 return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2));
963 } else {
964 return PBJ._PBJ.CastQuaternion();
965 }
966 }
967 set {
968 super.ClearOrientation();
969 float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value);
970 super.AddOrientation(_PBJtempArray[0]);
971 super.AddOrientation(_PBJtempArray[1]);
972 super.AddOrientation(_PBJtempArray[2]);
973 }
974 }
975 public Builder ClearVelocity() { super.ClearVelocity();return this;}
976 public const int VelocityFieldTag=5;
977 public bool HasVelocity{ get {return super.VelocityCount>=3;} }
978 public PBJ.Vector3f Velocity{ get {
979 int index=0;
980 if (HasVelocity) {
981 return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2));
982 } else {
983 return PBJ._PBJ.CastVector3f();
984 }
985 }
986 set {
987 super.ClearVelocity();
988 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
989 super.AddVelocity(_PBJtempArray[0]);
990 super.AddVelocity(_PBJtempArray[1]);
991 super.AddVelocity(_PBJtempArray[2]);
992 }
993 }
994 public Builder ClearRotationalAxis() { super.ClearRotationalAxis();return this;}
995 public const int RotationalAxisFieldTag=7;
996 public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} }
997 public PBJ.Vector3f RotationalAxis{ get {
998 int index=0;
999 if (HasRotationalAxis) {
1000 return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1));
1001 } else {
1002 return PBJ._PBJ.CastNormal();
1003 }
1004 }
1005 set {
1006 super.ClearRotationalAxis();
1007 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1008 super.AddRotationalAxis(_PBJtempArray[0]);
1009 super.AddRotationalAxis(_PBJtempArray[1]);
1010 }
1011 }
1012 public Builder ClearAngularSpeed() { super.ClearAngularSpeed();return this;}
1013 public const int AngularSpeedFieldTag=8;
1014 public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} }
1015 public float AngularSpeed{ get {
1016 if (HasAngularSpeed) {
1017 return PBJ._PBJ.CastFloat(super.AngularSpeed);
1018 } else {
1019 return PBJ._PBJ.CastFloat();
1020 }
1021 }
1022 set {
1023 super.AngularSpeed=(PBJ._PBJ.Construct(value));
1024 }
1025 }
1026 public Builder ClearUpdateFlags() { super.ClearUpdateFlags();return this;}
1027 public const int UpdateFlagsFieldTag=6;
1028 public bool HasUpdateFlags { get {
1029 if (!super.HasUpdateFlags) return false;
1030 return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
1031 } }
1032 public byte UpdateFlags{ get {
1033 if (HasUpdateFlags) {
1034 return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
1035 } else {
1036 return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE);
1037 }
1038 }
1039 set {
1040 super.UpdateFlags=((value));
1041 }
1042 }
1043 }
1044 }
1045}
1046namespace Sirikata.Protocol {
1047 public class LocRequest : PBJ.IMessage {
1048 protected _PBJ_Internal.LocRequest super;
1049 public _PBJ_Internal.LocRequest _PBJSuper{ get { return super;} }
1050 public LocRequest() {
1051 super=new _PBJ_Internal.LocRequest();
1052 }
1053 public LocRequest(_PBJ_Internal.LocRequest reference) {
1054 super=reference;
1055 }
1056 public static LocRequest defaultInstance= new LocRequest (_PBJ_Internal.LocRequest.DefaultInstance);
1057 public static LocRequest DefaultInstance{
1058 get {return defaultInstance;}
1059 }
1060 public static pbd.MessageDescriptor Descriptor {
1061 get { return _PBJ_Internal.LocRequest.Descriptor; } }
1062 public static class Types {
1063 public enum Fields {
1064 POSITION=_PBJ_Internal.LocRequest.Types.Fields.POSITION,
1065 ORIENTATION=_PBJ_Internal.LocRequest.Types.Fields.ORIENTATION,
1066 VELOCITY=_PBJ_Internal.LocRequest.Types.Fields.VELOCITY,
1067 ROTATIONAL_AXIS=_PBJ_Internal.LocRequest.Types.Fields.ROTATIONAL_AXIS,
1068 ANGULAR_SPEED=_PBJ_Internal.LocRequest.Types.Fields.ANGULAR_SPEED
1069 };
1070 }
1071 public static bool WithinReservedFieldTagRange(int field_tag) {
1072 return false;
1073 }
1074 public static bool WithinExtensionFieldTagRange(int field_tag) {
1075 return false;
1076 }
1077 public const int RequestedFieldsFieldTag=2;
1078 public bool HasRequestedFields { get {
1079 if (!super.HasRequestedFields) return false;
1080 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);
1081 } }
1082 public uint RequestedFields{ get {
1083 if (HasRequestedFields) {
1084 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);
1085 } else {
1086 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);
1087 }
1088 }
1089 }
1090 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1091 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1092 public static Builder CreateBuilder() { return new Builder(); }
1093 public static Builder CreateBuilder(LocRequest prototype) {
1094 return (Builder)new Builder().MergeFrom(prototype);
1095 }
1096 public static LocRequest ParseFrom(pb::ByteString data) {
1097 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1098 }
1099 public static LocRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1100 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1101 }
1102 public static LocRequest ParseFrom(byte[] data) {
1103 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1104 }
1105 public static LocRequest ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1106 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1107 }
1108 public static LocRequest ParseFrom(global::System.IO.Stream data) {
1109 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1110 }
1111 public static LocRequest ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1112 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1113 }
1114 public static LocRequest ParseFrom(pb::CodedInputStream data) {
1115 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1116 }
1117 public static LocRequest ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1118 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1119 }
1120 protected override bool _HasAllPBJFields{ get {
1121 return true
1122 ;
1123 } }
1124 public bool IsInitialized { get {
1125 return super.IsInitialized&&_HasAllPBJFields;
1126 } }
1127 public class Builder : global::PBJ.IMessage.IBuilder{
1128 protected override bool _HasAllPBJFields{ get {
1129 return true
1130 ;
1131 } }
1132 public bool IsInitialized { get {
1133 return super.IsInitialized&&_HasAllPBJFields;
1134 } }
1135 protected _PBJ_Internal.LocRequest.Builder super;
1136 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1137 public _PBJ_Internal.LocRequest.Builder _PBJSuper{ get { return super;} }
1138 public Builder() {super = new _PBJ_Internal.LocRequest.Builder();}
1139 public Builder(_PBJ_Internal.LocRequest.Builder other) {
1140 super=other;
1141 }
1142 public Builder Clone() {return new Builder(super.Clone());}
1143 public Builder MergeFrom(LocRequest prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1144 public Builder Clear() {super.Clear();return this;}
1145 public LocRequest BuildPartial() {return new LocRequest(super.BuildPartial());}
1146 public LocRequest Build() {if (_HasAllPBJFields) return new LocRequest(super.Build());return null;}
1147 public pbd::MessageDescriptor DescriptorForType {
1148 get { return LocRequest.Descriptor; } }
1149 public Builder ClearRequestedFields() { super.ClearRequestedFields();return this;}
1150 public const int RequestedFieldsFieldTag=2;
1151 public bool HasRequestedFields { get {
1152 if (!super.HasRequestedFields) return false;
1153 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);
1154 } }
1155 public uint RequestedFields{ get {
1156 if (HasRequestedFields) {
1157 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);
1158 } else {
1159 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);
1160 }
1161 }
1162 set {
1163 super.RequestedFields=((value));
1164 }
1165 }
1166 }
1167 }
1168}
1169namespace Sirikata.Protocol {
1170 public class NewObj : PBJ.IMessage {
1171 protected _PBJ_Internal.NewObj super;
1172 public _PBJ_Internal.NewObj _PBJSuper{ get { return super;} }
1173 public NewObj() {
1174 super=new _PBJ_Internal.NewObj();
1175 }
1176 public NewObj(_PBJ_Internal.NewObj reference) {
1177 super=reference;
1178 }
1179 public static NewObj defaultInstance= new NewObj (_PBJ_Internal.NewObj.DefaultInstance);
1180 public static NewObj DefaultInstance{
1181 get {return defaultInstance;}
1182 }
1183 public static pbd.MessageDescriptor Descriptor {
1184 get { return _PBJ_Internal.NewObj.Descriptor; } }
1185 public static class Types {
1186 }
1187 public static bool WithinReservedFieldTagRange(int field_tag) {
1188 return false;
1189 }
1190 public static bool WithinExtensionFieldTagRange(int field_tag) {
1191 return false;
1192 }
1193 public const int ObjectUuidEvidenceFieldTag=2;
1194 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
1195 public PBJ.UUID ObjectUuidEvidence{ get {
1196 if (HasObjectUuidEvidence) {
1197 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
1198 } else {
1199 return PBJ._PBJ.CastUuid();
1200 }
1201 }
1202 }
1203 public const int RequestedObjectLocFieldTag=3;
1204 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
1205 public ObjLoc RequestedObjectLoc{ get {
1206 if (HasRequestedObjectLoc) {
1207 return new ObjLoc(super.RequestedObjectLoc);
1208 } else {
1209 return new ObjLoc();
1210 }
1211 }
1212 }
1213 public const int BoundingSphereFieldTag=4;
1214 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1215 public PBJ.BoundingSphere3f BoundingSphere{ get {
1216 int index=0;
1217 if (HasBoundingSphere) {
1218 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1219 } else {
1220 return PBJ._PBJ.CastBoundingsphere3f();
1221 }
1222 }
1223 }
1224 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1225 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1226 public static Builder CreateBuilder() { return new Builder(); }
1227 public static Builder CreateBuilder(NewObj prototype) {
1228 return (Builder)new Builder().MergeFrom(prototype);
1229 }
1230 public static NewObj ParseFrom(pb::ByteString data) {
1231 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1232 }
1233 public static NewObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1234 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1235 }
1236 public static NewObj ParseFrom(byte[] data) {
1237 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1238 }
1239 public static NewObj ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1240 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1241 }
1242 public static NewObj ParseFrom(global::System.IO.Stream data) {
1243 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1244 }
1245 public static NewObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1246 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1247 }
1248 public static NewObj ParseFrom(pb::CodedInputStream data) {
1249 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1250 }
1251 public static NewObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1252 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1253 }
1254 protected override bool _HasAllPBJFields{ get {
1255 return true
1256 ;
1257 } }
1258 public bool IsInitialized { get {
1259 return super.IsInitialized&&_HasAllPBJFields;
1260 } }
1261 public class Builder : global::PBJ.IMessage.IBuilder{
1262 protected override bool _HasAllPBJFields{ get {
1263 return true
1264 ;
1265 } }
1266 public bool IsInitialized { get {
1267 return super.IsInitialized&&_HasAllPBJFields;
1268 } }
1269 protected _PBJ_Internal.NewObj.Builder super;
1270 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1271 public _PBJ_Internal.NewObj.Builder _PBJSuper{ get { return super;} }
1272 public Builder() {super = new _PBJ_Internal.NewObj.Builder();}
1273 public Builder(_PBJ_Internal.NewObj.Builder other) {
1274 super=other;
1275 }
1276 public Builder Clone() {return new Builder(super.Clone());}
1277 public Builder MergeFrom(NewObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1278 public Builder Clear() {super.Clear();return this;}
1279 public NewObj BuildPartial() {return new NewObj(super.BuildPartial());}
1280 public NewObj Build() {if (_HasAllPBJFields) return new NewObj(super.Build());return null;}
1281 public pbd::MessageDescriptor DescriptorForType {
1282 get { return NewObj.Descriptor; } }
1283 public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;}
1284 public const int ObjectUuidEvidenceFieldTag=2;
1285 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
1286 public PBJ.UUID ObjectUuidEvidence{ get {
1287 if (HasObjectUuidEvidence) {
1288 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
1289 } else {
1290 return PBJ._PBJ.CastUuid();
1291 }
1292 }
1293 set {
1294 super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value));
1295 }
1296 }
1297 public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;}
1298 public const int RequestedObjectLocFieldTag=3;
1299 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
1300 public ObjLoc RequestedObjectLoc{ get {
1301 if (HasRequestedObjectLoc) {
1302 return new ObjLoc(super.RequestedObjectLoc);
1303 } else {
1304 return new ObjLoc();
1305 }
1306 }
1307 set {
1308 super.RequestedObjectLoc=value._PBJSuper;
1309 }
1310 }
1311 public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;}
1312 public const int BoundingSphereFieldTag=4;
1313 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1314 public PBJ.BoundingSphere3f BoundingSphere{ get {
1315 int index=0;
1316 if (HasBoundingSphere) {
1317 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1318 } else {
1319 return PBJ._PBJ.CastBoundingsphere3f();
1320 }
1321 }
1322 set {
1323 super.ClearBoundingSphere();
1324 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
1325 super.AddBoundingSphere(_PBJtempArray[0]);
1326 super.AddBoundingSphere(_PBJtempArray[1]);
1327 super.AddBoundingSphere(_PBJtempArray[2]);
1328 super.AddBoundingSphere(_PBJtempArray[3]);
1329 }
1330 }
1331 }
1332 }
1333}
1334namespace Sirikata.Protocol {
1335 public class RetObj : PBJ.IMessage {
1336 protected _PBJ_Internal.RetObj super;
1337 public _PBJ_Internal.RetObj _PBJSuper{ get { return super;} }
1338 public RetObj() {
1339 super=new _PBJ_Internal.RetObj();
1340 }
1341 public RetObj(_PBJ_Internal.RetObj reference) {
1342 super=reference;
1343 }
1344 public static RetObj defaultInstance= new RetObj (_PBJ_Internal.RetObj.DefaultInstance);
1345 public static RetObj DefaultInstance{
1346 get {return defaultInstance;}
1347 }
1348 public static pbd.MessageDescriptor Descriptor {
1349 get { return _PBJ_Internal.RetObj.Descriptor; } }
1350 public static class Types {
1351 }
1352 public static bool WithinReservedFieldTagRange(int field_tag) {
1353 return false;
1354 }
1355 public static bool WithinExtensionFieldTagRange(int field_tag) {
1356 return false;
1357 }
1358 public const int ObjectReferenceFieldTag=2;
1359 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1360 public PBJ.UUID ObjectReference{ get {
1361 if (HasObjectReference) {
1362 return PBJ._PBJ.CastUuid(super.ObjectReference);
1363 } else {
1364 return PBJ._PBJ.CastUuid();
1365 }
1366 }
1367 }
1368 public const int LocationFieldTag=3;
1369 public bool HasLocation{ get {return super.HasLocation;} }
1370 public ObjLoc Location{ get {
1371 if (HasLocation) {
1372 return new ObjLoc(super.Location);
1373 } else {
1374 return new ObjLoc();
1375 }
1376 }
1377 }
1378 public const int BoundingSphereFieldTag=4;
1379 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1380 public PBJ.BoundingSphere3f BoundingSphere{ get {
1381 int index=0;
1382 if (HasBoundingSphere) {
1383 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1384 } else {
1385 return PBJ._PBJ.CastBoundingsphere3f();
1386 }
1387 }
1388 }
1389 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1390 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1391 public static Builder CreateBuilder() { return new Builder(); }
1392 public static Builder CreateBuilder(RetObj prototype) {
1393 return (Builder)new Builder().MergeFrom(prototype);
1394 }
1395 public static RetObj ParseFrom(pb::ByteString data) {
1396 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1397 }
1398 public static RetObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1399 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1400 }
1401 public static RetObj ParseFrom(byte[] data) {
1402 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1403 }
1404 public static RetObj ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1405 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1406 }
1407 public static RetObj ParseFrom(global::System.IO.Stream data) {
1408 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1409 }
1410 public static RetObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1411 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1412 }
1413 public static RetObj ParseFrom(pb::CodedInputStream data) {
1414 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1415 }
1416 public static RetObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1417 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1418 }
1419 protected override bool _HasAllPBJFields{ get {
1420 return true
1421 ;
1422 } }
1423 public bool IsInitialized { get {
1424 return super.IsInitialized&&_HasAllPBJFields;
1425 } }
1426 public class Builder : global::PBJ.IMessage.IBuilder{
1427 protected override bool _HasAllPBJFields{ get {
1428 return true
1429 ;
1430 } }
1431 public bool IsInitialized { get {
1432 return super.IsInitialized&&_HasAllPBJFields;
1433 } }
1434 protected _PBJ_Internal.RetObj.Builder super;
1435 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1436 public _PBJ_Internal.RetObj.Builder _PBJSuper{ get { return super;} }
1437 public Builder() {super = new _PBJ_Internal.RetObj.Builder();}
1438 public Builder(_PBJ_Internal.RetObj.Builder other) {
1439 super=other;
1440 }
1441 public Builder Clone() {return new Builder(super.Clone());}
1442 public Builder MergeFrom(RetObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1443 public Builder Clear() {super.Clear();return this;}
1444 public RetObj BuildPartial() {return new RetObj(super.BuildPartial());}
1445 public RetObj Build() {if (_HasAllPBJFields) return new RetObj(super.Build());return null;}
1446 public pbd::MessageDescriptor DescriptorForType {
1447 get { return RetObj.Descriptor; } }
1448 public Builder ClearObjectReference() { super.ClearObjectReference();return this;}
1449 public const int ObjectReferenceFieldTag=2;
1450 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1451 public PBJ.UUID ObjectReference{ get {
1452 if (HasObjectReference) {
1453 return PBJ._PBJ.CastUuid(super.ObjectReference);
1454 } else {
1455 return PBJ._PBJ.CastUuid();
1456 }
1457 }
1458 set {
1459 super.ObjectReference=(PBJ._PBJ.Construct(value));
1460 }
1461 }
1462 public Builder ClearLocation() { super.ClearLocation();return this;}
1463 public const int LocationFieldTag=3;
1464 public bool HasLocation{ get {return super.HasLocation;} }
1465 public ObjLoc Location{ get {
1466 if (HasLocation) {
1467 return new ObjLoc(super.Location);
1468 } else {
1469 return new ObjLoc();
1470 }
1471 }
1472 set {
1473 super.Location=value._PBJSuper;
1474 }
1475 }
1476 public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;}
1477 public const int BoundingSphereFieldTag=4;
1478 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1479 public PBJ.BoundingSphere3f BoundingSphere{ get {
1480 int index=0;
1481 if (HasBoundingSphere) {
1482 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1483 } else {
1484 return PBJ._PBJ.CastBoundingsphere3f();
1485 }
1486 }
1487 set {
1488 super.ClearBoundingSphere();
1489 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
1490 super.AddBoundingSphere(_PBJtempArray[0]);
1491 super.AddBoundingSphere(_PBJtempArray[1]);
1492 super.AddBoundingSphere(_PBJtempArray[2]);
1493 super.AddBoundingSphere(_PBJtempArray[3]);
1494 }
1495 }
1496 }
1497 }
1498}
1499namespace Sirikata.Protocol {
1500 public class DelObj : PBJ.IMessage {
1501 protected _PBJ_Internal.DelObj super;
1502 public _PBJ_Internal.DelObj _PBJSuper{ get { return super;} }
1503 public DelObj() {
1504 super=new _PBJ_Internal.DelObj();
1505 }
1506 public DelObj(_PBJ_Internal.DelObj reference) {
1507 super=reference;
1508 }
1509 public static DelObj defaultInstance= new DelObj (_PBJ_Internal.DelObj.DefaultInstance);
1510 public static DelObj DefaultInstance{
1511 get {return defaultInstance;}
1512 }
1513 public static pbd.MessageDescriptor Descriptor {
1514 get { return _PBJ_Internal.DelObj.Descriptor; } }
1515 public static class Types {
1516 }
1517 public static bool WithinReservedFieldTagRange(int field_tag) {
1518 return false;
1519 }
1520 public static bool WithinExtensionFieldTagRange(int field_tag) {
1521 return false;
1522 }
1523 public const int ObjectReferenceFieldTag=2;
1524 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1525 public PBJ.UUID ObjectReference{ get {
1526 if (HasObjectReference) {
1527 return PBJ._PBJ.CastUuid(super.ObjectReference);
1528 } else {
1529 return PBJ._PBJ.CastUuid();
1530 }
1531 }
1532 }
1533 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1534 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1535 public static Builder CreateBuilder() { return new Builder(); }
1536 public static Builder CreateBuilder(DelObj prototype) {
1537 return (Builder)new Builder().MergeFrom(prototype);
1538 }
1539 public static DelObj ParseFrom(pb::ByteString data) {
1540 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1541 }
1542 public static DelObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1543 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1544 }
1545 public static DelObj ParseFrom(byte[] data) {
1546 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1547 }
1548 public static DelObj ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1549 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1550 }
1551 public static DelObj ParseFrom(global::System.IO.Stream data) {
1552 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1553 }
1554 public static DelObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1555 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1556 }
1557 public static DelObj ParseFrom(pb::CodedInputStream data) {
1558 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1559 }
1560 public static DelObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1561 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1562 }
1563 protected override bool _HasAllPBJFields{ get {
1564 return true
1565 ;
1566 } }
1567 public bool IsInitialized { get {
1568 return super.IsInitialized&&_HasAllPBJFields;
1569 } }
1570 public class Builder : global::PBJ.IMessage.IBuilder{
1571 protected override bool _HasAllPBJFields{ get {
1572 return true
1573 ;
1574 } }
1575 public bool IsInitialized { get {
1576 return super.IsInitialized&&_HasAllPBJFields;
1577 } }
1578 protected _PBJ_Internal.DelObj.Builder super;
1579 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1580 public _PBJ_Internal.DelObj.Builder _PBJSuper{ get { return super;} }
1581 public Builder() {super = new _PBJ_Internal.DelObj.Builder();}
1582 public Builder(_PBJ_Internal.DelObj.Builder other) {
1583 super=other;
1584 }
1585 public Builder Clone() {return new Builder(super.Clone());}
1586 public Builder MergeFrom(DelObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1587 public Builder Clear() {super.Clear();return this;}
1588 public DelObj BuildPartial() {return new DelObj(super.BuildPartial());}
1589 public DelObj Build() {if (_HasAllPBJFields) return new DelObj(super.Build());return null;}
1590 public pbd::MessageDescriptor DescriptorForType {
1591 get { return DelObj.Descriptor; } }
1592 public Builder ClearObjectReference() { super.ClearObjectReference();return this;}
1593 public const int ObjectReferenceFieldTag=2;
1594 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1595 public PBJ.UUID ObjectReference{ get {
1596 if (HasObjectReference) {
1597 return PBJ._PBJ.CastUuid(super.ObjectReference);
1598 } else {
1599 return PBJ._PBJ.CastUuid();
1600 }
1601 }
1602 set {
1603 super.ObjectReference=(PBJ._PBJ.Construct(value));
1604 }
1605 }
1606 }
1607 }
1608}
1609namespace Sirikata.Protocol {
1610 public class NewProxQuery : PBJ.IMessage {
1611 protected _PBJ_Internal.NewProxQuery super;
1612 public _PBJ_Internal.NewProxQuery _PBJSuper{ get { return super;} }
1613 public NewProxQuery() {
1614 super=new _PBJ_Internal.NewProxQuery();
1615 }
1616 public NewProxQuery(_PBJ_Internal.NewProxQuery reference) {
1617 super=reference;
1618 }
1619 public static NewProxQuery defaultInstance= new NewProxQuery (_PBJ_Internal.NewProxQuery.DefaultInstance);
1620 public static NewProxQuery DefaultInstance{
1621 get {return defaultInstance;}
1622 }
1623 public static pbd.MessageDescriptor Descriptor {
1624 get { return _PBJ_Internal.NewProxQuery.Descriptor; } }
1625 public static class Types {
1626 }
1627 public static bool WithinReservedFieldTagRange(int field_tag) {
1628 return false;
1629 }
1630 public static bool WithinExtensionFieldTagRange(int field_tag) {
1631 return false;
1632 }
1633 public const int QueryIdFieldTag=2;
1634 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1635 public uint QueryId{ get {
1636 if (HasQueryId) {
1637 return PBJ._PBJ.CastUint32(super.QueryId);
1638 } else {
1639 return PBJ._PBJ.CastUint32();
1640 }
1641 }
1642 }
1643 public const int StatelessFieldTag=3;
1644 public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} }
1645 public bool Stateless{ get {
1646 if (HasStateless) {
1647 return PBJ._PBJ.CastBool(super.Stateless);
1648 } else {
1649 return PBJ._PBJ.CastBool();
1650 }
1651 }
1652 }
1653 public const int RelativeCenterFieldTag=4;
1654 public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} }
1655 public PBJ.Vector3f RelativeCenter{ get {
1656 int index=0;
1657 if (HasRelativeCenter) {
1658 return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2));
1659 } else {
1660 return PBJ._PBJ.CastVector3f();
1661 }
1662 }
1663 }
1664 public const int AbsoluteCenterFieldTag=5;
1665 public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} }
1666 public PBJ.Vector3d AbsoluteCenter{ get {
1667 int index=0;
1668 if (HasAbsoluteCenter) {
1669 return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2));
1670 } else {
1671 return PBJ._PBJ.CastVector3d();
1672 }
1673 }
1674 }
1675 public const int MaxRadiusFieldTag=6;
1676 public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} }
1677 public float MaxRadius{ get {
1678 if (HasMaxRadius) {
1679 return PBJ._PBJ.CastFloat(super.MaxRadius);
1680 } else {
1681 return PBJ._PBJ.CastFloat();
1682 }
1683 }
1684 }
1685 public const int MinSolidAngleFieldTag=7;
1686 public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} }
1687 public float MinSolidAngle{ get {
1688 if (HasMinSolidAngle) {
1689 return PBJ._PBJ.CastAngle(super.MinSolidAngle);
1690 } else {
1691 return PBJ._PBJ.CastAngle();
1692 }
1693 }
1694 }
1695 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1696 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1697 public static Builder CreateBuilder() { return new Builder(); }
1698 public static Builder CreateBuilder(NewProxQuery prototype) {
1699 return (Builder)new Builder().MergeFrom(prototype);
1700 }
1701 public static NewProxQuery ParseFrom(pb::ByteString data) {
1702 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1703 }
1704 public static NewProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1705 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1706 }
1707 public static NewProxQuery ParseFrom(byte[] data) {
1708 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1709 }
1710 public static NewProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1711 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1712 }
1713 public static NewProxQuery ParseFrom(global::System.IO.Stream data) {
1714 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1715 }
1716 public static NewProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1717 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1718 }
1719 public static NewProxQuery ParseFrom(pb::CodedInputStream data) {
1720 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1721 }
1722 public static NewProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1723 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1724 }
1725 protected override bool _HasAllPBJFields{ get {
1726 return true
1727 ;
1728 } }
1729 public bool IsInitialized { get {
1730 return super.IsInitialized&&_HasAllPBJFields;
1731 } }
1732 public class Builder : global::PBJ.IMessage.IBuilder{
1733 protected override bool _HasAllPBJFields{ get {
1734 return true
1735 ;
1736 } }
1737 public bool IsInitialized { get {
1738 return super.IsInitialized&&_HasAllPBJFields;
1739 } }
1740 protected _PBJ_Internal.NewProxQuery.Builder super;
1741 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1742 public _PBJ_Internal.NewProxQuery.Builder _PBJSuper{ get { return super;} }
1743 public Builder() {super = new _PBJ_Internal.NewProxQuery.Builder();}
1744 public Builder(_PBJ_Internal.NewProxQuery.Builder other) {
1745 super=other;
1746 }
1747 public Builder Clone() {return new Builder(super.Clone());}
1748 public Builder MergeFrom(NewProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1749 public Builder Clear() {super.Clear();return this;}
1750 public NewProxQuery BuildPartial() {return new NewProxQuery(super.BuildPartial());}
1751 public NewProxQuery Build() {if (_HasAllPBJFields) return new NewProxQuery(super.Build());return null;}
1752 public pbd::MessageDescriptor DescriptorForType {
1753 get { return NewProxQuery.Descriptor; } }
1754 public Builder ClearQueryId() { super.ClearQueryId();return this;}
1755 public const int QueryIdFieldTag=2;
1756 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1757 public uint QueryId{ get {
1758 if (HasQueryId) {
1759 return PBJ._PBJ.CastUint32(super.QueryId);
1760 } else {
1761 return PBJ._PBJ.CastUint32();
1762 }
1763 }
1764 set {
1765 super.QueryId=(PBJ._PBJ.Construct(value));
1766 }
1767 }
1768 public Builder ClearStateless() { super.ClearStateless();return this;}
1769 public const int StatelessFieldTag=3;
1770 public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} }
1771 public bool Stateless{ get {
1772 if (HasStateless) {
1773 return PBJ._PBJ.CastBool(super.Stateless);
1774 } else {
1775 return PBJ._PBJ.CastBool();
1776 }
1777 }
1778 set {
1779 super.Stateless=(PBJ._PBJ.Construct(value));
1780 }
1781 }
1782 public Builder ClearRelativeCenter() { super.ClearRelativeCenter();return this;}
1783 public const int RelativeCenterFieldTag=4;
1784 public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} }
1785 public PBJ.Vector3f RelativeCenter{ get {
1786 int index=0;
1787 if (HasRelativeCenter) {
1788 return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2));
1789 } else {
1790 return PBJ._PBJ.CastVector3f();
1791 }
1792 }
1793 set {
1794 super.ClearRelativeCenter();
1795 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
1796 super.AddRelativeCenter(_PBJtempArray[0]);
1797 super.AddRelativeCenter(_PBJtempArray[1]);
1798 super.AddRelativeCenter(_PBJtempArray[2]);
1799 }
1800 }
1801 public Builder ClearAbsoluteCenter() { super.ClearAbsoluteCenter();return this;}
1802 public const int AbsoluteCenterFieldTag=5;
1803 public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} }
1804 public PBJ.Vector3d AbsoluteCenter{ get {
1805 int index=0;
1806 if (HasAbsoluteCenter) {
1807 return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2));
1808 } else {
1809 return PBJ._PBJ.CastVector3d();
1810 }
1811 }
1812 set {
1813 super.ClearAbsoluteCenter();
1814 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
1815 super.AddAbsoluteCenter(_PBJtempArray[0]);
1816 super.AddAbsoluteCenter(_PBJtempArray[1]);
1817 super.AddAbsoluteCenter(_PBJtempArray[2]);
1818 }
1819 }
1820 public Builder ClearMaxRadius() { super.ClearMaxRadius();return this;}
1821 public const int MaxRadiusFieldTag=6;
1822 public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} }
1823 public float MaxRadius{ get {
1824 if (HasMaxRadius) {
1825 return PBJ._PBJ.CastFloat(super.MaxRadius);
1826 } else {
1827 return PBJ._PBJ.CastFloat();
1828 }
1829 }
1830 set {
1831 super.MaxRadius=(PBJ._PBJ.Construct(value));
1832 }
1833 }
1834 public Builder ClearMinSolidAngle() { super.ClearMinSolidAngle();return this;}
1835 public const int MinSolidAngleFieldTag=7;
1836 public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} }
1837 public float MinSolidAngle{ get {
1838 if (HasMinSolidAngle) {
1839 return PBJ._PBJ.CastAngle(super.MinSolidAngle);
1840 } else {
1841 return PBJ._PBJ.CastAngle();
1842 }
1843 }
1844 set {
1845 super.MinSolidAngle=(PBJ._PBJ.Construct(value));
1846 }
1847 }
1848 }
1849 }
1850}
1851namespace Sirikata.Protocol {
1852 public class ProxCall : PBJ.IMessage {
1853 protected _PBJ_Internal.ProxCall super;
1854 public _PBJ_Internal.ProxCall _PBJSuper{ get { return super;} }
1855 public ProxCall() {
1856 super=new _PBJ_Internal.ProxCall();
1857 }
1858 public ProxCall(_PBJ_Internal.ProxCall reference) {
1859 super=reference;
1860 }
1861 public static ProxCall defaultInstance= new ProxCall (_PBJ_Internal.ProxCall.DefaultInstance);
1862 public static ProxCall DefaultInstance{
1863 get {return defaultInstance;}
1864 }
1865 public static pbd.MessageDescriptor Descriptor {
1866 get { return _PBJ_Internal.ProxCall.Descriptor; } }
1867 public static class Types {
1868 public enum ProximityEvent {
1869 EXITED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY,
1870 ENTERED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.ENTERED_PROXIMITY,
1871 STATELESS_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.STATELESS_PROXIMITY
1872 };
1873 }
1874 public static bool WithinReservedFieldTagRange(int field_tag) {
1875 return false;
1876 }
1877 public static bool WithinExtensionFieldTagRange(int field_tag) {
1878 return false;
1879 }
1880 public const int QueryIdFieldTag=2;
1881 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1882 public uint QueryId{ get {
1883 if (HasQueryId) {
1884 return PBJ._PBJ.CastUint32(super.QueryId);
1885 } else {
1886 return PBJ._PBJ.CastUint32();
1887 }
1888 }
1889 }
1890 public const int ProximateObjectFieldTag=3;
1891 public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} }
1892 public PBJ.UUID ProximateObject{ get {
1893 if (HasProximateObject) {
1894 return PBJ._PBJ.CastUuid(super.ProximateObject);
1895 } else {
1896 return PBJ._PBJ.CastUuid();
1897 }
1898 }
1899 }
1900 public const int ProximityEventFieldTag=4;
1901 public bool HasProximityEvent{ get {return super.HasProximityEvent;} }
1902 public Types.ProximityEvent ProximityEvent{ get {
1903 if (HasProximityEvent) {
1904 return (Types.ProximityEvent)super.ProximityEvent;
1905 } else {
1906 return new Types.ProximityEvent();
1907 }
1908 }
1909 }
1910 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1911 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1912 public static Builder CreateBuilder() { return new Builder(); }
1913 public static Builder CreateBuilder(ProxCall prototype) {
1914 return (Builder)new Builder().MergeFrom(prototype);
1915 }
1916 public static ProxCall ParseFrom(pb::ByteString data) {
1917 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1918 }
1919 public static ProxCall ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1920 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1921 }
1922 public static ProxCall ParseFrom(byte[] data) {
1923 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1924 }
1925 public static ProxCall ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1926 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1927 }
1928 public static ProxCall ParseFrom(global::System.IO.Stream data) {
1929 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1930 }
1931 public static ProxCall ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1932 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1933 }
1934 public static ProxCall ParseFrom(pb::CodedInputStream data) {
1935 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1936 }
1937 public static ProxCall ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1938 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1939 }
1940 protected override bool _HasAllPBJFields{ get {
1941 return true
1942 ;
1943 } }
1944 public bool IsInitialized { get {
1945 return super.IsInitialized&&_HasAllPBJFields;
1946 } }
1947 public class Builder : global::PBJ.IMessage.IBuilder{
1948 protected override bool _HasAllPBJFields{ get {
1949 return true
1950 ;
1951 } }
1952 public bool IsInitialized { get {
1953 return super.IsInitialized&&_HasAllPBJFields;
1954 } }
1955 protected _PBJ_Internal.ProxCall.Builder super;
1956 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1957 public _PBJ_Internal.ProxCall.Builder _PBJSuper{ get { return super;} }
1958 public Builder() {super = new _PBJ_Internal.ProxCall.Builder();}
1959 public Builder(_PBJ_Internal.ProxCall.Builder other) {
1960 super=other;
1961 }
1962 public Builder Clone() {return new Builder(super.Clone());}
1963 public Builder MergeFrom(ProxCall prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1964 public Builder Clear() {super.Clear();return this;}
1965 public ProxCall BuildPartial() {return new ProxCall(super.BuildPartial());}
1966 public ProxCall Build() {if (_HasAllPBJFields) return new ProxCall(super.Build());return null;}
1967 public pbd::MessageDescriptor DescriptorForType {
1968 get { return ProxCall.Descriptor; } }
1969 public Builder ClearQueryId() { super.ClearQueryId();return this;}
1970 public const int QueryIdFieldTag=2;
1971 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1972 public uint QueryId{ get {
1973 if (HasQueryId) {
1974 return PBJ._PBJ.CastUint32(super.QueryId);
1975 } else {
1976 return PBJ._PBJ.CastUint32();
1977 }
1978 }
1979 set {
1980 super.QueryId=(PBJ._PBJ.Construct(value));
1981 }
1982 }
1983 public Builder ClearProximateObject() { super.ClearProximateObject();return this;}
1984 public const int ProximateObjectFieldTag=3;
1985 public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} }
1986 public PBJ.UUID ProximateObject{ get {
1987 if (HasProximateObject) {
1988 return PBJ._PBJ.CastUuid(super.ProximateObject);
1989 } else {
1990 return PBJ._PBJ.CastUuid();
1991 }
1992 }
1993 set {
1994 super.ProximateObject=(PBJ._PBJ.Construct(value));
1995 }
1996 }
1997 public Builder ClearProximityEvent() { super.ClearProximityEvent();return this;}
1998 public const int ProximityEventFieldTag=4;
1999 public bool HasProximityEvent{ get {return super.HasProximityEvent;} }
2000 public Types.ProximityEvent ProximityEvent{ get {
2001 if (HasProximityEvent) {
2002 return (Types.ProximityEvent)super.ProximityEvent;
2003 } else {
2004 return new Types.ProximityEvent();
2005 }
2006 }
2007 set {
2008 super.ProximityEvent=((_PBJ_Internal.ProxCall.Types.ProximityEvent)value);
2009 }
2010 }
2011 }
2012 }
2013}
2014namespace Sirikata.Protocol {
2015 public class DelProxQuery : PBJ.IMessage {
2016 protected _PBJ_Internal.DelProxQuery super;
2017 public _PBJ_Internal.DelProxQuery _PBJSuper{ get { return super;} }
2018 public DelProxQuery() {
2019 super=new _PBJ_Internal.DelProxQuery();
2020 }
2021 public DelProxQuery(_PBJ_Internal.DelProxQuery reference) {
2022 super=reference;
2023 }
2024 public static DelProxQuery defaultInstance= new DelProxQuery (_PBJ_Internal.DelProxQuery.DefaultInstance);
2025 public static DelProxQuery DefaultInstance{
2026 get {return defaultInstance;}
2027 }
2028 public static pbd.MessageDescriptor Descriptor {
2029 get { return _PBJ_Internal.DelProxQuery.Descriptor; } }
2030 public static class Types {
2031 }
2032 public static bool WithinReservedFieldTagRange(int field_tag) {
2033 return false;
2034 }
2035 public static bool WithinExtensionFieldTagRange(int field_tag) {
2036 return false;
2037 }
2038 public const int QueryIdFieldTag=2;
2039 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
2040 public uint QueryId{ get {
2041 if (HasQueryId) {
2042 return PBJ._PBJ.CastUint32(super.QueryId);
2043 } else {
2044 return PBJ._PBJ.CastUint32();
2045 }
2046 }
2047 }
2048 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2049 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2050 public static Builder CreateBuilder() { return new Builder(); }
2051 public static Builder CreateBuilder(DelProxQuery prototype) {
2052 return (Builder)new Builder().MergeFrom(prototype);
2053 }
2054 public static DelProxQuery ParseFrom(pb::ByteString data) {
2055 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2056 }
2057 public static DelProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2058 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2059 }
2060 public static DelProxQuery ParseFrom(byte[] data) {
2061 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2062 }
2063 public static DelProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2064 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2065 }
2066 public static DelProxQuery ParseFrom(global::System.IO.Stream data) {
2067 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2068 }
2069 public static DelProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2070 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2071 }
2072 public static DelProxQuery ParseFrom(pb::CodedInputStream data) {
2073 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2074 }
2075 public static DelProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2076 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2077 }
2078 protected override bool _HasAllPBJFields{ get {
2079 return true
2080 ;
2081 } }
2082 public bool IsInitialized { get {
2083 return super.IsInitialized&&_HasAllPBJFields;
2084 } }
2085 public class Builder : global::PBJ.IMessage.IBuilder{
2086 protected override bool _HasAllPBJFields{ get {
2087 return true
2088 ;
2089 } }
2090 public bool IsInitialized { get {
2091 return super.IsInitialized&&_HasAllPBJFields;
2092 } }
2093 protected _PBJ_Internal.DelProxQuery.Builder super;
2094 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2095 public _PBJ_Internal.DelProxQuery.Builder _PBJSuper{ get { return super;} }
2096 public Builder() {super = new _PBJ_Internal.DelProxQuery.Builder();}
2097 public Builder(_PBJ_Internal.DelProxQuery.Builder other) {
2098 super=other;
2099 }
2100 public Builder Clone() {return new Builder(super.Clone());}
2101 public Builder MergeFrom(DelProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2102 public Builder Clear() {super.Clear();return this;}
2103 public DelProxQuery BuildPartial() {return new DelProxQuery(super.BuildPartial());}
2104 public DelProxQuery Build() {if (_HasAllPBJFields) return new DelProxQuery(super.Build());return null;}
2105 public pbd::MessageDescriptor DescriptorForType {
2106 get { return DelProxQuery.Descriptor; } }
2107 public Builder ClearQueryId() { super.ClearQueryId();return this;}
2108 public const int QueryIdFieldTag=2;
2109 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
2110 public uint QueryId{ get {
2111 if (HasQueryId) {
2112 return PBJ._PBJ.CastUint32(super.QueryId);
2113 } else {
2114 return PBJ._PBJ.CastUint32();
2115 }
2116 }
2117 set {
2118 super.QueryId=(PBJ._PBJ.Construct(value));
2119 }
2120 }
2121 }
2122 }
2123}
2124namespace Sirikata.Protocol {
2125 public class Vector3fProperty : PBJ.IMessage {
2126 protected _PBJ_Internal.Vector3fProperty super;
2127 public _PBJ_Internal.Vector3fProperty _PBJSuper{ get { return super;} }
2128 public Vector3fProperty() {
2129 super=new _PBJ_Internal.Vector3fProperty();
2130 }
2131 public Vector3fProperty(_PBJ_Internal.Vector3fProperty reference) {
2132 super=reference;
2133 }
2134 public static Vector3fProperty defaultInstance= new Vector3fProperty (_PBJ_Internal.Vector3fProperty.DefaultInstance);
2135 public static Vector3fProperty DefaultInstance{
2136 get {return defaultInstance;}
2137 }
2138 public static pbd.MessageDescriptor Descriptor {
2139 get { return _PBJ_Internal.Vector3fProperty.Descriptor; } }
2140 public static class Types {
2141 }
2142 public static bool WithinReservedFieldTagRange(int field_tag) {
2143 return false;
2144 }
2145 public static bool WithinExtensionFieldTagRange(int field_tag) {
2146 return false;
2147 }
2148 public const int ValueFieldTag=10;
2149 public bool HasValue{ get {return super.ValueCount>=3;} }
2150 public PBJ.Vector3f Value{ get {
2151 int index=0;
2152 if (HasValue) {
2153 return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2));
2154 } else {
2155 return PBJ._PBJ.CastVector3f();
2156 }
2157 }
2158 }
2159 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2160 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2161 public static Builder CreateBuilder() { return new Builder(); }
2162 public static Builder CreateBuilder(Vector3fProperty prototype) {
2163 return (Builder)new Builder().MergeFrom(prototype);
2164 }
2165 public static Vector3fProperty ParseFrom(pb::ByteString data) {
2166 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2167 }
2168 public static Vector3fProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2169 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2170 }
2171 public static Vector3fProperty ParseFrom(byte[] data) {
2172 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2173 }
2174 public static Vector3fProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2175 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2176 }
2177 public static Vector3fProperty ParseFrom(global::System.IO.Stream data) {
2178 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2179 }
2180 public static Vector3fProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2181 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2182 }
2183 public static Vector3fProperty ParseFrom(pb::CodedInputStream data) {
2184 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2185 }
2186 public static Vector3fProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2187 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2188 }
2189 protected override bool _HasAllPBJFields{ get {
2190 return true
2191 ;
2192 } }
2193 public bool IsInitialized { get {
2194 return super.IsInitialized&&_HasAllPBJFields;
2195 } }
2196 public class Builder : global::PBJ.IMessage.IBuilder{
2197 protected override bool _HasAllPBJFields{ get {
2198 return true
2199 ;
2200 } }
2201 public bool IsInitialized { get {
2202 return super.IsInitialized&&_HasAllPBJFields;
2203 } }
2204 protected _PBJ_Internal.Vector3fProperty.Builder super;
2205 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2206 public _PBJ_Internal.Vector3fProperty.Builder _PBJSuper{ get { return super;} }
2207 public Builder() {super = new _PBJ_Internal.Vector3fProperty.Builder();}
2208 public Builder(_PBJ_Internal.Vector3fProperty.Builder other) {
2209 super=other;
2210 }
2211 public Builder Clone() {return new Builder(super.Clone());}
2212 public Builder MergeFrom(Vector3fProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2213 public Builder Clear() {super.Clear();return this;}
2214 public Vector3fProperty BuildPartial() {return new Vector3fProperty(super.BuildPartial());}
2215 public Vector3fProperty Build() {if (_HasAllPBJFields) return new Vector3fProperty(super.Build());return null;}
2216 public pbd::MessageDescriptor DescriptorForType {
2217 get { return Vector3fProperty.Descriptor; } }
2218 public Builder ClearValue() { super.ClearValue();return this;}
2219 public const int ValueFieldTag=10;
2220 public bool HasValue{ get {return super.ValueCount>=3;} }
2221 public PBJ.Vector3f Value{ get {
2222 int index=0;
2223 if (HasValue) {
2224 return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2));
2225 } else {
2226 return PBJ._PBJ.CastVector3f();
2227 }
2228 }
2229 set {
2230 super.ClearValue();
2231 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
2232 super.AddValue(_PBJtempArray[0]);
2233 super.AddValue(_PBJtempArray[1]);
2234 super.AddValue(_PBJtempArray[2]);
2235 }
2236 }
2237 }
2238 }
2239}
2240namespace Sirikata.Protocol {
2241 public class StringProperty : PBJ.IMessage {
2242 protected _PBJ_Internal.StringProperty super;
2243 public _PBJ_Internal.StringProperty _PBJSuper{ get { return super;} }
2244 public StringProperty() {
2245 super=new _PBJ_Internal.StringProperty();
2246 }
2247 public StringProperty(_PBJ_Internal.StringProperty reference) {
2248 super=reference;
2249 }
2250 public static StringProperty defaultInstance= new StringProperty (_PBJ_Internal.StringProperty.DefaultInstance);
2251 public static StringProperty DefaultInstance{
2252 get {return defaultInstance;}
2253 }
2254 public static pbd.MessageDescriptor Descriptor {
2255 get { return _PBJ_Internal.StringProperty.Descriptor; } }
2256 public static class Types {
2257 }
2258 public static bool WithinReservedFieldTagRange(int field_tag) {
2259 return false;
2260 }
2261 public static bool WithinExtensionFieldTagRange(int field_tag) {
2262 return false;
2263 }
2264 public const int ValueFieldTag=10;
2265 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} }
2266 public string Value{ get {
2267 if (HasValue) {
2268 return PBJ._PBJ.CastString(super.Value);
2269 } else {
2270 return PBJ._PBJ.CastString();
2271 }
2272 }
2273 }
2274 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2275 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2276 public static Builder CreateBuilder() { return new Builder(); }
2277 public static Builder CreateBuilder(StringProperty prototype) {
2278 return (Builder)new Builder().MergeFrom(prototype);
2279 }
2280 public static StringProperty ParseFrom(pb::ByteString data) {
2281 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2282 }
2283 public static StringProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2284 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2285 }
2286 public static StringProperty ParseFrom(byte[] data) {
2287 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2288 }
2289 public static StringProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2290 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2291 }
2292 public static StringProperty ParseFrom(global::System.IO.Stream data) {
2293 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2294 }
2295 public static StringProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2296 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2297 }
2298 public static StringProperty ParseFrom(pb::CodedInputStream data) {
2299 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2300 }
2301 public static StringProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2302 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2303 }
2304 protected override bool _HasAllPBJFields{ get {
2305 return true
2306 ;
2307 } }
2308 public bool IsInitialized { get {
2309 return super.IsInitialized&&_HasAllPBJFields;
2310 } }
2311 public class Builder : global::PBJ.IMessage.IBuilder{
2312 protected override bool _HasAllPBJFields{ get {
2313 return true
2314 ;
2315 } }
2316 public bool IsInitialized { get {
2317 return super.IsInitialized&&_HasAllPBJFields;
2318 } }
2319 protected _PBJ_Internal.StringProperty.Builder super;
2320 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2321 public _PBJ_Internal.StringProperty.Builder _PBJSuper{ get { return super;} }
2322 public Builder() {super = new _PBJ_Internal.StringProperty.Builder();}
2323 public Builder(_PBJ_Internal.StringProperty.Builder other) {
2324 super=other;
2325 }
2326 public Builder Clone() {return new Builder(super.Clone());}
2327 public Builder MergeFrom(StringProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2328 public Builder Clear() {super.Clear();return this;}
2329 public StringProperty BuildPartial() {return new StringProperty(super.BuildPartial());}
2330 public StringProperty Build() {if (_HasAllPBJFields) return new StringProperty(super.Build());return null;}
2331 public pbd::MessageDescriptor DescriptorForType {
2332 get { return StringProperty.Descriptor; } }
2333 public Builder ClearValue() { super.ClearValue();return this;}
2334 public const int ValueFieldTag=10;
2335 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} }
2336 public string Value{ get {
2337 if (HasValue) {
2338 return PBJ._PBJ.CastString(super.Value);
2339 } else {
2340 return PBJ._PBJ.CastString();
2341 }
2342 }
2343 set {
2344 super.Value=(PBJ._PBJ.Construct(value));
2345 }
2346 }
2347 }
2348 }
2349}
2350namespace Sirikata.Protocol {
2351 public class StringMapProperty : PBJ.IMessage {
2352 protected _PBJ_Internal.StringMapProperty super;
2353 public _PBJ_Internal.StringMapProperty _PBJSuper{ get { return super;} }
2354 public StringMapProperty() {
2355 super=new _PBJ_Internal.StringMapProperty();
2356 }
2357 public StringMapProperty(_PBJ_Internal.StringMapProperty reference) {
2358 super=reference;
2359 }
2360 public static StringMapProperty defaultInstance= new StringMapProperty (_PBJ_Internal.StringMapProperty.DefaultInstance);
2361 public static StringMapProperty DefaultInstance{
2362 get {return defaultInstance;}
2363 }
2364 public static pbd.MessageDescriptor Descriptor {
2365 get { return _PBJ_Internal.StringMapProperty.Descriptor; } }
2366 public static class Types {
2367 }
2368 public static bool WithinReservedFieldTagRange(int field_tag) {
2369 return false;
2370 }
2371 public static bool WithinExtensionFieldTagRange(int field_tag) {
2372 return false;
2373 }
2374 public const int KeysFieldTag=2;
2375 public int KeysCount { get { return super.KeysCount;} }
2376 public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));}
2377 public string Keys(int index) {
2378 return (string)PBJ._PBJ.CastString(super.GetKeys(index));
2379 }
2380 public const int ValuesFieldTag=3;
2381 public int ValuesCount { get { return super.ValuesCount;} }
2382 public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));}
2383 public string Values(int index) {
2384 return (string)PBJ._PBJ.CastString(super.GetValues(index));
2385 }
2386 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2387 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2388 public static Builder CreateBuilder() { return new Builder(); }
2389 public static Builder CreateBuilder(StringMapProperty prototype) {
2390 return (Builder)new Builder().MergeFrom(prototype);
2391 }
2392 public static StringMapProperty ParseFrom(pb::ByteString data) {
2393 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2394 }
2395 public static StringMapProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2396 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2397 }
2398 public static StringMapProperty ParseFrom(byte[] data) {
2399 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2400 }
2401 public static StringMapProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2402 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2403 }
2404 public static StringMapProperty ParseFrom(global::System.IO.Stream data) {
2405 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2406 }
2407 public static StringMapProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2408 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2409 }
2410 public static StringMapProperty ParseFrom(pb::CodedInputStream data) {
2411 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2412 }
2413 public static StringMapProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2414 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2415 }
2416 protected override bool _HasAllPBJFields{ get {
2417 return true
2418 ;
2419 } }
2420 public bool IsInitialized { get {
2421 return super.IsInitialized&&_HasAllPBJFields;
2422 } }
2423 public class Builder : global::PBJ.IMessage.IBuilder{
2424 protected override bool _HasAllPBJFields{ get {
2425 return true
2426 ;
2427 } }
2428 public bool IsInitialized { get {
2429 return super.IsInitialized&&_HasAllPBJFields;
2430 } }
2431 protected _PBJ_Internal.StringMapProperty.Builder super;
2432 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2433 public _PBJ_Internal.StringMapProperty.Builder _PBJSuper{ get { return super;} }
2434 public Builder() {super = new _PBJ_Internal.StringMapProperty.Builder();}
2435 public Builder(_PBJ_Internal.StringMapProperty.Builder other) {
2436 super=other;
2437 }
2438 public Builder Clone() {return new Builder(super.Clone());}
2439 public Builder MergeFrom(StringMapProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2440 public Builder Clear() {super.Clear();return this;}
2441 public StringMapProperty BuildPartial() {return new StringMapProperty(super.BuildPartial());}
2442 public StringMapProperty Build() {if (_HasAllPBJFields) return new StringMapProperty(super.Build());return null;}
2443 public pbd::MessageDescriptor DescriptorForType {
2444 get { return StringMapProperty.Descriptor; } }
2445 public Builder ClearKeys() { super.ClearKeys();return this;}
2446 public Builder SetKeys(int index, string value) {
2447 super.SetKeys(index,PBJ._PBJ.Construct(value));
2448 return this;
2449 }
2450 public const int KeysFieldTag=2;
2451 public int KeysCount { get { return super.KeysCount;} }
2452 public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));}
2453 public string Keys(int index) {
2454 return (string)PBJ._PBJ.CastString(super.GetKeys(index));
2455 }
2456 public Builder AddKeys(string value) {
2457 super.AddKeys(PBJ._PBJ.Construct(value));
2458 return this;
2459 }
2460 public Builder ClearValues() { super.ClearValues();return this;}
2461 public Builder SetValues(int index, string value) {
2462 super.SetValues(index,PBJ._PBJ.Construct(value));
2463 return this;
2464 }
2465 public const int ValuesFieldTag=3;
2466 public int ValuesCount { get { return super.ValuesCount;} }
2467 public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));}
2468 public string Values(int index) {
2469 return (string)PBJ._PBJ.CastString(super.GetValues(index));
2470 }
2471 public Builder AddValues(string value) {
2472 super.AddValues(PBJ._PBJ.Construct(value));
2473 return this;
2474 }
2475 }
2476 }
2477}
2478namespace Sirikata.Protocol {
2479 public class PhysicalParameters : PBJ.IMessage {
2480 protected _PBJ_Internal.PhysicalParameters super;
2481 public _PBJ_Internal.PhysicalParameters _PBJSuper{ get { return super;} }
2482 public PhysicalParameters() {
2483 super=new _PBJ_Internal.PhysicalParameters();
2484 }
2485 public PhysicalParameters(_PBJ_Internal.PhysicalParameters reference) {
2486 super=reference;
2487 }
2488 public static PhysicalParameters defaultInstance= new PhysicalParameters (_PBJ_Internal.PhysicalParameters.DefaultInstance);
2489 public static PhysicalParameters DefaultInstance{
2490 get {return defaultInstance;}
2491 }
2492 public static pbd.MessageDescriptor Descriptor {
2493 get { return _PBJ_Internal.PhysicalParameters.Descriptor; } }
2494 public static class Types {
2495 public enum Mode {
2496 NONPHYSICAL=_PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL,
2497 STATIC=_PBJ_Internal.PhysicalParameters.Types.Mode.STATIC,
2498 DYNAMICBOX=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICBOX,
2499 DYNAMICSPHERE=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICSPHERE,
2500 DYNAMICCYLINDER=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICCYLINDER,
2501 CHARACTER=_PBJ_Internal.PhysicalParameters.Types.Mode.CHARACTER
2502 };
2503 }
2504 public static bool WithinReservedFieldTagRange(int field_tag) {
2505 return false;
2506 }
2507 public static bool WithinExtensionFieldTagRange(int field_tag) {
2508 return false;
2509 }
2510 public const int ModeFieldTag=2;
2511 public bool HasMode{ get {return super.HasMode;} }
2512 public Types.Mode Mode{ get {
2513 if (HasMode) {
2514 return (Types.Mode)super.Mode;
2515 } else {
2516 return new Types.Mode();
2517 }
2518 }
2519 }
2520 public const int DensityFieldTag=3;
2521 public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} }
2522 public float Density{ get {
2523 if (HasDensity) {
2524 return PBJ._PBJ.CastFloat(super.Density);
2525 } else {
2526 return PBJ._PBJ.CastFloat();
2527 }
2528 }
2529 }
2530 public const int FrictionFieldTag=4;
2531 public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} }
2532 public float Friction{ get {
2533 if (HasFriction) {
2534 return PBJ._PBJ.CastFloat(super.Friction);
2535 } else {
2536 return PBJ._PBJ.CastFloat();
2537 }
2538 }
2539 }
2540 public const int BounceFieldTag=5;
2541 public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} }
2542 public float Bounce{ get {
2543 if (HasBounce) {
2544 return PBJ._PBJ.CastFloat(super.Bounce);
2545 } else {
2546 return PBJ._PBJ.CastFloat();
2547 }
2548 }
2549 }
2550 public const int HullFieldTag=6;
2551 public bool HasHull{ get {return super.HullCount>=3;} }
2552 public PBJ.Vector3f Hull{ get {
2553 int index=0;
2554 if (HasHull) {
2555 return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2));
2556 } else {
2557 return PBJ._PBJ.CastVector3f();
2558 }
2559 }
2560 }
2561 public const int CollideMsgFieldTag=16;
2562 public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} }
2563 public uint CollideMsg{ get {
2564 if (HasCollideMsg) {
2565 return PBJ._PBJ.CastUint32(super.CollideMsg);
2566 } else {
2567 return PBJ._PBJ.CastUint32();
2568 }
2569 }
2570 }
2571 public const int CollideMaskFieldTag=17;
2572 public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} }
2573 public uint CollideMask{ get {
2574 if (HasCollideMask) {
2575 return PBJ._PBJ.CastUint32(super.CollideMask);
2576 } else {
2577 return PBJ._PBJ.CastUint32();
2578 }
2579 }
2580 }
2581 public const int GravityFieldTag=18;
2582 public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} }
2583 public float Gravity{ get {
2584 if (HasGravity) {
2585 return PBJ._PBJ.CastFloat(super.Gravity);
2586 } else {
2587 return PBJ._PBJ.CastFloat();
2588 }
2589 }
2590 }
2591 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2592 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2593 public static Builder CreateBuilder() { return new Builder(); }
2594 public static Builder CreateBuilder(PhysicalParameters prototype) {
2595 return (Builder)new Builder().MergeFrom(prototype);
2596 }
2597 public static PhysicalParameters ParseFrom(pb::ByteString data) {
2598 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2599 }
2600 public static PhysicalParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2601 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2602 }
2603 public static PhysicalParameters ParseFrom(byte[] data) {
2604 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2605 }
2606 public static PhysicalParameters ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2607 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2608 }
2609 public static PhysicalParameters ParseFrom(global::System.IO.Stream data) {
2610 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2611 }
2612 public static PhysicalParameters ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2613 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2614 }
2615 public static PhysicalParameters ParseFrom(pb::CodedInputStream data) {
2616 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2617 }
2618 public static PhysicalParameters ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2619 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2620 }
2621 protected override bool _HasAllPBJFields{ get {
2622 return true
2623 ;
2624 } }
2625 public bool IsInitialized { get {
2626 return super.IsInitialized&&_HasAllPBJFields;
2627 } }
2628 public class Builder : global::PBJ.IMessage.IBuilder{
2629 protected override bool _HasAllPBJFields{ get {
2630 return true
2631 ;
2632 } }
2633 public bool IsInitialized { get {
2634 return super.IsInitialized&&_HasAllPBJFields;
2635 } }
2636 protected _PBJ_Internal.PhysicalParameters.Builder super;
2637 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2638 public _PBJ_Internal.PhysicalParameters.Builder _PBJSuper{ get { return super;} }
2639 public Builder() {super = new _PBJ_Internal.PhysicalParameters.Builder();}
2640 public Builder(_PBJ_Internal.PhysicalParameters.Builder other) {
2641 super=other;
2642 }
2643 public Builder Clone() {return new Builder(super.Clone());}
2644 public Builder MergeFrom(PhysicalParameters prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2645 public Builder Clear() {super.Clear();return this;}
2646 public PhysicalParameters BuildPartial() {return new PhysicalParameters(super.BuildPartial());}
2647 public PhysicalParameters Build() {if (_HasAllPBJFields) return new PhysicalParameters(super.Build());return null;}
2648 public pbd::MessageDescriptor DescriptorForType {
2649 get { return PhysicalParameters.Descriptor; } }
2650 public Builder ClearMode() { super.ClearMode();return this;}
2651 public const int ModeFieldTag=2;
2652 public bool HasMode{ get {return super.HasMode;} }
2653 public Types.Mode Mode{ get {
2654 if (HasMode) {
2655 return (Types.Mode)super.Mode;
2656 } else {
2657 return new Types.Mode();
2658 }
2659 }
2660 set {
2661 super.Mode=((_PBJ_Internal.PhysicalParameters.Types.Mode)value);
2662 }
2663 }
2664 public Builder ClearDensity() { super.ClearDensity();return this;}
2665 public const int DensityFieldTag=3;
2666 public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} }
2667 public float Density{ get {
2668 if (HasDensity) {
2669 return PBJ._PBJ.CastFloat(super.Density);
2670 } else {
2671 return PBJ._PBJ.CastFloat();
2672 }
2673 }
2674 set {
2675 super.Density=(PBJ._PBJ.Construct(value));
2676 }
2677 }
2678 public Builder ClearFriction() { super.ClearFriction();return this;}
2679 public const int FrictionFieldTag=4;
2680 public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} }
2681 public float Friction{ get {
2682 if (HasFriction) {
2683 return PBJ._PBJ.CastFloat(super.Friction);
2684 } else {
2685 return PBJ._PBJ.CastFloat();
2686 }
2687 }
2688 set {
2689 super.Friction=(PBJ._PBJ.Construct(value));
2690 }
2691 }
2692 public Builder ClearBounce() { super.ClearBounce();return this;}
2693 public const int BounceFieldTag=5;
2694 public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} }
2695 public float Bounce{ get {
2696 if (HasBounce) {
2697 return PBJ._PBJ.CastFloat(super.Bounce);
2698 } else {
2699 return PBJ._PBJ.CastFloat();
2700 }
2701 }
2702 set {
2703 super.Bounce=(PBJ._PBJ.Construct(value));
2704 }
2705 }
2706 public Builder ClearHull() { super.ClearHull();return this;}
2707 public const int HullFieldTag=6;
2708 public bool HasHull{ get {return super.HullCount>=3;} }
2709 public PBJ.Vector3f Hull{ get {
2710 int index=0;
2711 if (HasHull) {
2712 return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2));
2713 } else {
2714 return PBJ._PBJ.CastVector3f();
2715 }
2716 }
2717 set {
2718 super.ClearHull();
2719 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
2720 super.AddHull(_PBJtempArray[0]);
2721 super.AddHull(_PBJtempArray[1]);
2722 super.AddHull(_PBJtempArray[2]);
2723 }
2724 }
2725 public Builder ClearCollideMsg() { super.ClearCollideMsg();return this;}
2726 public const int CollideMsgFieldTag=16;
2727 public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} }
2728 public uint CollideMsg{ get {
2729 if (HasCollideMsg) {
2730 return PBJ._PBJ.CastUint32(super.CollideMsg);
2731 } else {
2732 return PBJ._PBJ.CastUint32();
2733 }
2734 }
2735 set {
2736 super.CollideMsg=(PBJ._PBJ.Construct(value));
2737 }
2738 }
2739 public Builder ClearCollideMask() { super.ClearCollideMask();return this;}
2740 public const int CollideMaskFieldTag=17;
2741 public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} }
2742 public uint CollideMask{ get {
2743 if (HasCollideMask) {
2744 return PBJ._PBJ.CastUint32(super.CollideMask);
2745 } else {
2746 return PBJ._PBJ.CastUint32();
2747 }
2748 }
2749 set {
2750 super.CollideMask=(PBJ._PBJ.Construct(value));
2751 }
2752 }
2753 public Builder ClearGravity() { super.ClearGravity();return this;}
2754 public const int GravityFieldTag=18;
2755 public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} }
2756 public float Gravity{ get {
2757 if (HasGravity) {
2758 return PBJ._PBJ.CastFloat(super.Gravity);
2759 } else {
2760 return PBJ._PBJ.CastFloat();
2761 }
2762 }
2763 set {
2764 super.Gravity=(PBJ._PBJ.Construct(value));
2765 }
2766 }
2767 }
2768 }
2769}
2770namespace Sirikata.Protocol {
2771 public class LightInfoProperty : PBJ.IMessage {
2772 protected _PBJ_Internal.LightInfoProperty super;
2773 public _PBJ_Internal.LightInfoProperty _PBJSuper{ get { return super;} }
2774 public LightInfoProperty() {
2775 super=new _PBJ_Internal.LightInfoProperty();
2776 }
2777 public LightInfoProperty(_PBJ_Internal.LightInfoProperty reference) {
2778 super=reference;
2779 }
2780 public static LightInfoProperty defaultInstance= new LightInfoProperty (_PBJ_Internal.LightInfoProperty.DefaultInstance);
2781 public static LightInfoProperty DefaultInstance{
2782 get {return defaultInstance;}
2783 }
2784 public static pbd.MessageDescriptor Descriptor {
2785 get { return _PBJ_Internal.LightInfoProperty.Descriptor; } }
2786 public static class Types {
2787 public enum LightTypes {
2788 POINT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT,
2789 SPOTLIGHT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.SPOTLIGHT,
2790 DIRECTIONAL=_PBJ_Internal.LightInfoProperty.Types.LightTypes.DIRECTIONAL
2791 };
2792 }
2793 public static bool WithinReservedFieldTagRange(int field_tag) {
2794 return false;
2795 }
2796 public static bool WithinExtensionFieldTagRange(int field_tag) {
2797 return false;
2798 }
2799 public const int DiffuseColorFieldTag=3;
2800 public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} }
2801 public PBJ.Vector3f DiffuseColor{ get {
2802 int index=0;
2803 if (HasDiffuseColor) {
2804 return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2));
2805 } else {
2806 return PBJ._PBJ.CastVector3f();
2807 }
2808 }
2809 }
2810 public const int SpecularColorFieldTag=4;
2811 public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} }
2812 public PBJ.Vector3f SpecularColor{ get {
2813 int index=0;
2814 if (HasSpecularColor) {
2815 return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2));
2816 } else {
2817 return PBJ._PBJ.CastVector3f();
2818 }
2819 }
2820 }
2821 public const int PowerFieldTag=5;
2822 public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} }
2823 public float Power{ get {
2824 if (HasPower) {
2825 return PBJ._PBJ.CastFloat(super.Power);
2826 } else {
2827 return PBJ._PBJ.CastFloat();
2828 }
2829 }
2830 }
2831 public const int AmbientColorFieldTag=6;
2832 public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} }
2833 public PBJ.Vector3f AmbientColor{ get {
2834 int index=0;
2835 if (HasAmbientColor) {
2836 return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2));
2837 } else {
2838 return PBJ._PBJ.CastVector3f();
2839 }
2840 }
2841 }
2842 public const int ShadowColorFieldTag=7;
2843 public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} }
2844 public PBJ.Vector3f ShadowColor{ get {
2845 int index=0;
2846 if (HasShadowColor) {
2847 return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2));
2848 } else {
2849 return PBJ._PBJ.CastVector3f();
2850 }
2851 }
2852 }
2853 public const int LightRangeFieldTag=8;
2854 public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} }
2855 public double LightRange{ get {
2856 if (HasLightRange) {
2857 return PBJ._PBJ.CastDouble(super.LightRange);
2858 } else {
2859 return PBJ._PBJ.CastDouble();
2860 }
2861 }
2862 }
2863 public const int ConstantFalloffFieldTag=9;
2864 public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} }
2865 public float ConstantFalloff{ get {
2866 if (HasConstantFalloff) {
2867 return PBJ._PBJ.CastFloat(super.ConstantFalloff);
2868 } else {
2869 return PBJ._PBJ.CastFloat();
2870 }
2871 }
2872 }
2873 public const int LinearFalloffFieldTag=10;
2874 public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} }
2875 public float LinearFalloff{ get {
2876 if (HasLinearFalloff) {
2877 return PBJ._PBJ.CastFloat(super.LinearFalloff);
2878 } else {
2879 return PBJ._PBJ.CastFloat();
2880 }
2881 }
2882 }
2883 public const int QuadraticFalloffFieldTag=11;
2884 public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} }
2885 public float QuadraticFalloff{ get {
2886 if (HasQuadraticFalloff) {
2887 return PBJ._PBJ.CastFloat(super.QuadraticFalloff);
2888 } else {
2889 return PBJ._PBJ.CastFloat();
2890 }
2891 }
2892 }
2893 public const int ConeInnerRadiansFieldTag=12;
2894 public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} }
2895 public float ConeInnerRadians{ get {
2896 if (HasConeInnerRadians) {
2897 return PBJ._PBJ.CastFloat(super.ConeInnerRadians);
2898 } else {
2899 return PBJ._PBJ.CastFloat();
2900 }
2901 }
2902 }
2903 public const int ConeOuterRadiansFieldTag=13;
2904 public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} }
2905 public float ConeOuterRadians{ get {
2906 if (HasConeOuterRadians) {
2907 return PBJ._PBJ.CastFloat(super.ConeOuterRadians);
2908 } else {
2909 return PBJ._PBJ.CastFloat();
2910 }
2911 }
2912 }
2913 public const int ConeFalloffFieldTag=14;
2914 public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} }
2915 public float ConeFalloff{ get {
2916 if (HasConeFalloff) {
2917 return PBJ._PBJ.CastFloat(super.ConeFalloff);
2918 } else {
2919 return PBJ._PBJ.CastFloat();
2920 }
2921 }
2922 }
2923 public const int TypeFieldTag=15;
2924 public bool HasType{ get {return super.HasType;} }
2925 public Types.LightTypes Type{ get {
2926 if (HasType) {
2927 return (Types.LightTypes)super.Type;
2928 } else {
2929 return new Types.LightTypes();
2930 }
2931 }
2932 }
2933 public const int CastsShadowFieldTag=16;
2934 public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} }
2935 public bool CastsShadow{ get {
2936 if (HasCastsShadow) {
2937 return PBJ._PBJ.CastBool(super.CastsShadow);
2938 } else {
2939 return PBJ._PBJ.CastBool();
2940 }
2941 }
2942 }
2943 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2944 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2945 public static Builder CreateBuilder() { return new Builder(); }
2946 public static Builder CreateBuilder(LightInfoProperty prototype) {
2947 return (Builder)new Builder().MergeFrom(prototype);
2948 }
2949 public static LightInfoProperty ParseFrom(pb::ByteString data) {
2950 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2951 }
2952 public static LightInfoProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2953 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2954 }
2955 public static LightInfoProperty ParseFrom(byte[] data) {
2956 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2957 }
2958 public static LightInfoProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2959 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2960 }
2961 public static LightInfoProperty ParseFrom(global::System.IO.Stream data) {
2962 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2963 }
2964 public static LightInfoProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2965 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2966 }
2967 public static LightInfoProperty ParseFrom(pb::CodedInputStream data) {
2968 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2969 }
2970 public static LightInfoProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2971 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2972 }
2973 protected override bool _HasAllPBJFields{ get {
2974 return true
2975 ;
2976 } }
2977 public bool IsInitialized { get {
2978 return super.IsInitialized&&_HasAllPBJFields;
2979 } }
2980 public class Builder : global::PBJ.IMessage.IBuilder{
2981 protected override bool _HasAllPBJFields{ get {
2982 return true
2983 ;
2984 } }
2985 public bool IsInitialized { get {
2986 return super.IsInitialized&&_HasAllPBJFields;
2987 } }
2988 protected _PBJ_Internal.LightInfoProperty.Builder super;
2989 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2990 public _PBJ_Internal.LightInfoProperty.Builder _PBJSuper{ get { return super;} }
2991 public Builder() {super = new _PBJ_Internal.LightInfoProperty.Builder();}
2992 public Builder(_PBJ_Internal.LightInfoProperty.Builder other) {
2993 super=other;
2994 }
2995 public Builder Clone() {return new Builder(super.Clone());}
2996 public Builder MergeFrom(LightInfoProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2997 public Builder Clear() {super.Clear();return this;}
2998 public LightInfoProperty BuildPartial() {return new LightInfoProperty(super.BuildPartial());}
2999 public LightInfoProperty Build() {if (_HasAllPBJFields) return new LightInfoProperty(super.Build());return null;}
3000 public pbd::MessageDescriptor DescriptorForType {
3001 get { return LightInfoProperty.Descriptor; } }
3002 public Builder ClearDiffuseColor() { super.ClearDiffuseColor();return this;}
3003 public const int DiffuseColorFieldTag=3;
3004 public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} }
3005 public PBJ.Vector3f DiffuseColor{ get {
3006 int index=0;
3007 if (HasDiffuseColor) {
3008 return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2));
3009 } else {
3010 return PBJ._PBJ.CastVector3f();
3011 }
3012 }
3013 set {
3014 super.ClearDiffuseColor();
3015 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3016 super.AddDiffuseColor(_PBJtempArray[0]);
3017 super.AddDiffuseColor(_PBJtempArray[1]);
3018 super.AddDiffuseColor(_PBJtempArray[2]);
3019 }
3020 }
3021 public Builder ClearSpecularColor() { super.ClearSpecularColor();return this;}
3022 public const int SpecularColorFieldTag=4;
3023 public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} }
3024 public PBJ.Vector3f SpecularColor{ get {
3025 int index=0;
3026 if (HasSpecularColor) {
3027 return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2));
3028 } else {
3029 return PBJ._PBJ.CastVector3f();
3030 }
3031 }
3032 set {
3033 super.ClearSpecularColor();
3034 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3035 super.AddSpecularColor(_PBJtempArray[0]);
3036 super.AddSpecularColor(_PBJtempArray[1]);
3037 super.AddSpecularColor(_PBJtempArray[2]);
3038 }
3039 }
3040 public Builder ClearPower() { super.ClearPower();return this;}
3041 public const int PowerFieldTag=5;
3042 public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} }
3043 public float Power{ get {
3044 if (HasPower) {
3045 return PBJ._PBJ.CastFloat(super.Power);
3046 } else {
3047 return PBJ._PBJ.CastFloat();
3048 }
3049 }
3050 set {
3051 super.Power=(PBJ._PBJ.Construct(value));
3052 }
3053 }
3054 public Builder ClearAmbientColor() { super.ClearAmbientColor();return this;}
3055 public const int AmbientColorFieldTag=6;
3056 public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} }
3057 public PBJ.Vector3f AmbientColor{ get {
3058 int index=0;
3059 if (HasAmbientColor) {
3060 return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2));
3061 } else {
3062 return PBJ._PBJ.CastVector3f();
3063 }
3064 }
3065 set {
3066 super.ClearAmbientColor();
3067 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3068 super.AddAmbientColor(_PBJtempArray[0]);
3069 super.AddAmbientColor(_PBJtempArray[1]);
3070 super.AddAmbientColor(_PBJtempArray[2]);
3071 }
3072 }
3073 public Builder ClearShadowColor() { super.ClearShadowColor();return this;}
3074 public const int ShadowColorFieldTag=7;
3075 public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} }
3076 public PBJ.Vector3f ShadowColor{ get {
3077 int index=0;
3078 if (HasShadowColor) {
3079 return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2));
3080 } else {
3081 return PBJ._PBJ.CastVector3f();
3082 }
3083 }
3084 set {
3085 super.ClearShadowColor();
3086 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3087 super.AddShadowColor(_PBJtempArray[0]);
3088 super.AddShadowColor(_PBJtempArray[1]);
3089 super.AddShadowColor(_PBJtempArray[2]);
3090 }
3091 }
3092 public Builder ClearLightRange() { super.ClearLightRange();return this;}
3093 public const int LightRangeFieldTag=8;
3094 public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} }
3095 public double LightRange{ get {
3096 if (HasLightRange) {
3097 return PBJ._PBJ.CastDouble(super.LightRange);
3098 } else {
3099 return PBJ._PBJ.CastDouble();
3100 }
3101 }
3102 set {
3103 super.LightRange=(PBJ._PBJ.Construct(value));
3104 }
3105 }
3106 public Builder ClearConstantFalloff() { super.ClearConstantFalloff();return this;}
3107 public const int ConstantFalloffFieldTag=9;
3108 public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} }
3109 public float ConstantFalloff{ get {
3110 if (HasConstantFalloff) {
3111 return PBJ._PBJ.CastFloat(super.ConstantFalloff);
3112 } else {
3113 return PBJ._PBJ.CastFloat();
3114 }
3115 }
3116 set {
3117 super.ConstantFalloff=(PBJ._PBJ.Construct(value));
3118 }
3119 }
3120 public Builder ClearLinearFalloff() { super.ClearLinearFalloff();return this;}
3121 public const int LinearFalloffFieldTag=10;
3122 public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} }
3123 public float LinearFalloff{ get {
3124 if (HasLinearFalloff) {
3125 return PBJ._PBJ.CastFloat(super.LinearFalloff);
3126 } else {
3127 return PBJ._PBJ.CastFloat();
3128 }
3129 }
3130 set {
3131 super.LinearFalloff=(PBJ._PBJ.Construct(value));
3132 }
3133 }
3134 public Builder ClearQuadraticFalloff() { super.ClearQuadraticFalloff();return this;}
3135 public const int QuadraticFalloffFieldTag=11;
3136 public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} }
3137 public float QuadraticFalloff{ get {
3138 if (HasQuadraticFalloff) {
3139 return PBJ._PBJ.CastFloat(super.QuadraticFalloff);
3140 } else {
3141 return PBJ._PBJ.CastFloat();
3142 }
3143 }
3144 set {
3145 super.QuadraticFalloff=(PBJ._PBJ.Construct(value));
3146 }
3147 }
3148 public Builder ClearConeInnerRadians() { super.ClearConeInnerRadians();return this;}
3149 public const int ConeInnerRadiansFieldTag=12;
3150 public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} }
3151 public float ConeInnerRadians{ get {
3152 if (HasConeInnerRadians) {
3153 return PBJ._PBJ.CastFloat(super.ConeInnerRadians);
3154 } else {
3155 return PBJ._PBJ.CastFloat();
3156 }
3157 }
3158 set {
3159 super.ConeInnerRadians=(PBJ._PBJ.Construct(value));
3160 }
3161 }
3162 public Builder ClearConeOuterRadians() { super.ClearConeOuterRadians();return this;}
3163 public const int ConeOuterRadiansFieldTag=13;
3164 public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} }
3165 public float ConeOuterRadians{ get {
3166 if (HasConeOuterRadians) {
3167 return PBJ._PBJ.CastFloat(super.ConeOuterRadians);
3168 } else {
3169 return PBJ._PBJ.CastFloat();
3170 }
3171 }
3172 set {
3173 super.ConeOuterRadians=(PBJ._PBJ.Construct(value));
3174 }
3175 }
3176 public Builder ClearConeFalloff() { super.ClearConeFalloff();return this;}
3177 public const int ConeFalloffFieldTag=14;
3178 public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} }
3179 public float ConeFalloff{ get {
3180 if (HasConeFalloff) {
3181 return PBJ._PBJ.CastFloat(super.ConeFalloff);
3182 } else {
3183 return PBJ._PBJ.CastFloat();
3184 }
3185 }
3186 set {
3187 super.ConeFalloff=(PBJ._PBJ.Construct(value));
3188 }
3189 }
3190 public Builder ClearType() { super.ClearType();return this;}
3191 public const int TypeFieldTag=15;
3192 public bool HasType{ get {return super.HasType;} }
3193 public Types.LightTypes Type{ get {
3194 if (HasType) {
3195 return (Types.LightTypes)super.Type;
3196 } else {
3197 return new Types.LightTypes();
3198 }
3199 }
3200 set {
3201 super.Type=((_PBJ_Internal.LightInfoProperty.Types.LightTypes)value);
3202 }
3203 }
3204 public Builder ClearCastsShadow() { super.ClearCastsShadow();return this;}
3205 public const int CastsShadowFieldTag=16;
3206 public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} }
3207 public bool CastsShadow{ get {
3208 if (HasCastsShadow) {
3209 return PBJ._PBJ.CastBool(super.CastsShadow);
3210 } else {
3211 return PBJ._PBJ.CastBool();
3212 }
3213 }
3214 set {
3215 super.CastsShadow=(PBJ._PBJ.Construct(value));
3216 }
3217 }
3218 }
3219 }
3220}
3221namespace Sirikata.Protocol {
3222 public class ParentProperty : PBJ.IMessage {
3223 protected _PBJ_Internal.ParentProperty super;
3224 public _PBJ_Internal.ParentProperty _PBJSuper{ get { return super;} }
3225 public ParentProperty() {
3226 super=new _PBJ_Internal.ParentProperty();
3227 }
3228 public ParentProperty(_PBJ_Internal.ParentProperty reference) {
3229 super=reference;
3230 }
3231 public static ParentProperty defaultInstance= new ParentProperty (_PBJ_Internal.ParentProperty.DefaultInstance);
3232 public static ParentProperty DefaultInstance{
3233 get {return defaultInstance;}
3234 }
3235 public static pbd.MessageDescriptor Descriptor {
3236 get { return _PBJ_Internal.ParentProperty.Descriptor; } }
3237 public static class Types {
3238 }
3239 public static bool WithinReservedFieldTagRange(int field_tag) {
3240 return false;
3241 }
3242 public static bool WithinExtensionFieldTagRange(int field_tag) {
3243 return false;
3244 }
3245 public const int ValueFieldTag=10;
3246 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} }
3247 public PBJ.UUID Value{ get {
3248 if (HasValue) {
3249 return PBJ._PBJ.CastUuid(super.Value);
3250 } else {
3251 return PBJ._PBJ.CastUuid();
3252 }
3253 }
3254 }
3255 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3256 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3257 public static Builder CreateBuilder() { return new Builder(); }
3258 public static Builder CreateBuilder(ParentProperty prototype) {
3259 return (Builder)new Builder().MergeFrom(prototype);
3260 }
3261 public static ParentProperty ParseFrom(pb::ByteString data) {
3262 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3263 }
3264 public static ParentProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3265 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3266 }
3267 public static ParentProperty ParseFrom(byte[] data) {
3268 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3269 }
3270 public static ParentProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3271 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3272 }
3273 public static ParentProperty ParseFrom(global::System.IO.Stream data) {
3274 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3275 }
3276 public static ParentProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3277 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3278 }
3279 public static ParentProperty ParseFrom(pb::CodedInputStream data) {
3280 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3281 }
3282 public static ParentProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3283 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3284 }
3285 protected override bool _HasAllPBJFields{ get {
3286 return true
3287 ;
3288 } }
3289 public bool IsInitialized { get {
3290 return super.IsInitialized&&_HasAllPBJFields;
3291 } }
3292 public class Builder : global::PBJ.IMessage.IBuilder{
3293 protected override bool _HasAllPBJFields{ get {
3294 return true
3295 ;
3296 } }
3297 public bool IsInitialized { get {
3298 return super.IsInitialized&&_HasAllPBJFields;
3299 } }
3300 protected _PBJ_Internal.ParentProperty.Builder super;
3301 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3302 public _PBJ_Internal.ParentProperty.Builder _PBJSuper{ get { return super;} }
3303 public Builder() {super = new _PBJ_Internal.ParentProperty.Builder();}
3304 public Builder(_PBJ_Internal.ParentProperty.Builder other) {
3305 super=other;
3306 }
3307 public Builder Clone() {return new Builder(super.Clone());}
3308 public Builder MergeFrom(ParentProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3309 public Builder Clear() {super.Clear();return this;}
3310 public ParentProperty BuildPartial() {return new ParentProperty(super.BuildPartial());}
3311 public ParentProperty Build() {if (_HasAllPBJFields) return new ParentProperty(super.Build());return null;}
3312 public pbd::MessageDescriptor DescriptorForType {
3313 get { return ParentProperty.Descriptor; } }
3314 public Builder ClearValue() { super.ClearValue();return this;}
3315 public const int ValueFieldTag=10;
3316 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} }
3317 public PBJ.UUID Value{ get {
3318 if (HasValue) {
3319 return PBJ._PBJ.CastUuid(super.Value);
3320 } else {
3321 return PBJ._PBJ.CastUuid();
3322 }
3323 }
3324 set {
3325 super.Value=(PBJ._PBJ.Construct(value));
3326 }
3327 }
3328 }
3329 }
3330}
3331namespace Sirikata.Protocol {
3332 public class UUIDListProperty : PBJ.IMessage {
3333 protected _PBJ_Internal.UUIDListProperty super;
3334 public _PBJ_Internal.UUIDListProperty _PBJSuper{ get { return super;} }
3335 public UUIDListProperty() {
3336 super=new _PBJ_Internal.UUIDListProperty();
3337 }
3338 public UUIDListProperty(_PBJ_Internal.UUIDListProperty reference) {
3339 super=reference;
3340 }
3341 public static UUIDListProperty defaultInstance= new UUIDListProperty (_PBJ_Internal.UUIDListProperty.DefaultInstance);
3342 public static UUIDListProperty DefaultInstance{
3343 get {return defaultInstance;}
3344 }
3345 public static pbd.MessageDescriptor Descriptor {
3346 get { return _PBJ_Internal.UUIDListProperty.Descriptor; } }
3347 public static class Types {
3348 }
3349 public static bool WithinReservedFieldTagRange(int field_tag) {
3350 return false;
3351 }
3352 public static bool WithinExtensionFieldTagRange(int field_tag) {
3353 return false;
3354 }
3355 public const int ValueFieldTag=10;
3356 public int ValueCount { get { return super.ValueCount;} }
3357 public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));}
3358 public PBJ.UUID Value(int index) {
3359 return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index));
3360 }
3361 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3362 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3363 public static Builder CreateBuilder() { return new Builder(); }
3364 public static Builder CreateBuilder(UUIDListProperty prototype) {
3365 return (Builder)new Builder().MergeFrom(prototype);
3366 }
3367 public static UUIDListProperty ParseFrom(pb::ByteString data) {
3368 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3369 }
3370 public static UUIDListProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3371 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3372 }
3373 public static UUIDListProperty ParseFrom(byte[] data) {
3374 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3375 }
3376 public static UUIDListProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3377 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3378 }
3379 public static UUIDListProperty ParseFrom(global::System.IO.Stream data) {
3380 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3381 }
3382 public static UUIDListProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3383 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3384 }
3385 public static UUIDListProperty ParseFrom(pb::CodedInputStream data) {
3386 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3387 }
3388 public static UUIDListProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3389 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3390 }
3391 protected override bool _HasAllPBJFields{ get {
3392 return true
3393 ;
3394 } }
3395 public bool IsInitialized { get {
3396 return super.IsInitialized&&_HasAllPBJFields;
3397 } }
3398 public class Builder : global::PBJ.IMessage.IBuilder{
3399 protected override bool _HasAllPBJFields{ get {
3400 return true
3401 ;
3402 } }
3403 public bool IsInitialized { get {
3404 return super.IsInitialized&&_HasAllPBJFields;
3405 } }
3406 protected _PBJ_Internal.UUIDListProperty.Builder super;
3407 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3408 public _PBJ_Internal.UUIDListProperty.Builder _PBJSuper{ get { return super;} }
3409 public Builder() {super = new _PBJ_Internal.UUIDListProperty.Builder();}
3410 public Builder(_PBJ_Internal.UUIDListProperty.Builder other) {
3411 super=other;
3412 }
3413 public Builder Clone() {return new Builder(super.Clone());}
3414 public Builder MergeFrom(UUIDListProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3415 public Builder Clear() {super.Clear();return this;}
3416 public UUIDListProperty BuildPartial() {return new UUIDListProperty(super.BuildPartial());}
3417 public UUIDListProperty Build() {if (_HasAllPBJFields) return new UUIDListProperty(super.Build());return null;}
3418 public pbd::MessageDescriptor DescriptorForType {
3419 get { return UUIDListProperty.Descriptor; } }
3420 public Builder ClearValue() { super.ClearValue();return this;}
3421 public Builder SetValue(int index, PBJ.UUID value) {
3422 super.SetValue(index,PBJ._PBJ.Construct(value));
3423 return this;
3424 }
3425 public const int ValueFieldTag=10;
3426 public int ValueCount { get { return super.ValueCount;} }
3427 public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));}
3428 public PBJ.UUID Value(int index) {
3429 return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index));
3430 }
3431 public Builder AddValue(PBJ.UUID value) {
3432 super.AddValue(PBJ._PBJ.Construct(value));
3433 return this;
3434 }
3435 }
3436 }
3437}
3438namespace Sirikata.Protocol {
3439 public class ConnectToSpace : PBJ.IMessage {
3440 protected _PBJ_Internal.ConnectToSpace super;
3441 public _PBJ_Internal.ConnectToSpace _PBJSuper{ get { return super;} }
3442 public ConnectToSpace() {
3443 super=new _PBJ_Internal.ConnectToSpace();
3444 }
3445 public ConnectToSpace(_PBJ_Internal.ConnectToSpace reference) {
3446 super=reference;
3447 }
3448 public static ConnectToSpace defaultInstance= new ConnectToSpace (_PBJ_Internal.ConnectToSpace.DefaultInstance);
3449 public static ConnectToSpace DefaultInstance{
3450 get {return defaultInstance;}
3451 }
3452 public static pbd.MessageDescriptor Descriptor {
3453 get { return _PBJ_Internal.ConnectToSpace.Descriptor; } }
3454 public static class Types {
3455 }
3456 public static bool WithinReservedFieldTagRange(int field_tag) {
3457 return false;
3458 }
3459 public static bool WithinExtensionFieldTagRange(int field_tag) {
3460 return false;
3461 }
3462 public const int SpaceIdFieldTag=1;
3463 public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} }
3464 public PBJ.UUID SpaceId{ get {
3465 if (HasSpaceId) {
3466 return PBJ._PBJ.CastUuid(super.SpaceId);
3467 } else {
3468 return PBJ._PBJ.CastUuid();
3469 }
3470 }
3471 }
3472 public const int ObjectUuidEvidenceFieldTag=2;
3473 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
3474 public PBJ.UUID ObjectUuidEvidence{ get {
3475 if (HasObjectUuidEvidence) {
3476 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
3477 } else {
3478 return PBJ._PBJ.CastUuid();
3479 }
3480 }
3481 }
3482 public const int RequestedObjectLocFieldTag=3;
3483 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
3484 public ObjLoc RequestedObjectLoc{ get {
3485 if (HasRequestedObjectLoc) {
3486 return new ObjLoc(super.RequestedObjectLoc);
3487 } else {
3488 return new ObjLoc();
3489 }
3490 }
3491 }
3492 public const int BoundingSphereFieldTag=4;
3493 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
3494 public PBJ.BoundingSphere3f BoundingSphere{ get {
3495 int index=0;
3496 if (HasBoundingSphere) {
3497 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
3498 } else {
3499 return PBJ._PBJ.CastBoundingsphere3f();
3500 }
3501 }
3502 }
3503 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3504 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3505 public static Builder CreateBuilder() { return new Builder(); }
3506 public static Builder CreateBuilder(ConnectToSpace prototype) {
3507 return (Builder)new Builder().MergeFrom(prototype);
3508 }
3509 public static ConnectToSpace ParseFrom(pb::ByteString data) {
3510 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3511 }
3512 public static ConnectToSpace ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3513 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3514 }
3515 public static ConnectToSpace ParseFrom(byte[] data) {
3516 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3517 }
3518 public static ConnectToSpace ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3519 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3520 }
3521 public static ConnectToSpace ParseFrom(global::System.IO.Stream data) {
3522 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3523 }
3524 public static ConnectToSpace ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3525 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3526 }
3527 public static ConnectToSpace ParseFrom(pb::CodedInputStream data) {
3528 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3529 }
3530 public static ConnectToSpace ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3531 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3532 }
3533 protected override bool _HasAllPBJFields{ get {
3534 return true
3535 ;
3536 } }
3537 public bool IsInitialized { get {
3538 return super.IsInitialized&&_HasAllPBJFields;
3539 } }
3540 public class Builder : global::PBJ.IMessage.IBuilder{
3541 protected override bool _HasAllPBJFields{ get {
3542 return true
3543 ;
3544 } }
3545 public bool IsInitialized { get {
3546 return super.IsInitialized&&_HasAllPBJFields;
3547 } }
3548 protected _PBJ_Internal.ConnectToSpace.Builder super;
3549 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3550 public _PBJ_Internal.ConnectToSpace.Builder _PBJSuper{ get { return super;} }
3551 public Builder() {super = new _PBJ_Internal.ConnectToSpace.Builder();}
3552 public Builder(_PBJ_Internal.ConnectToSpace.Builder other) {
3553 super=other;
3554 }
3555 public Builder Clone() {return new Builder(super.Clone());}
3556 public Builder MergeFrom(ConnectToSpace prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3557 public Builder Clear() {super.Clear();return this;}
3558 public ConnectToSpace BuildPartial() {return new ConnectToSpace(super.BuildPartial());}
3559 public ConnectToSpace Build() {if (_HasAllPBJFields) return new ConnectToSpace(super.Build());return null;}
3560 public pbd::MessageDescriptor DescriptorForType {
3561 get { return ConnectToSpace.Descriptor; } }
3562 public Builder ClearSpaceId() { super.ClearSpaceId();return this;}
3563 public const int SpaceIdFieldTag=1;
3564 public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} }
3565 public PBJ.UUID SpaceId{ get {
3566 if (HasSpaceId) {
3567 return PBJ._PBJ.CastUuid(super.SpaceId);
3568 } else {
3569 return PBJ._PBJ.CastUuid();
3570 }
3571 }
3572 set {
3573 super.SpaceId=(PBJ._PBJ.Construct(value));
3574 }
3575 }
3576 public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;}
3577 public const int ObjectUuidEvidenceFieldTag=2;
3578 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
3579 public PBJ.UUID ObjectUuidEvidence{ get {
3580 if (HasObjectUuidEvidence) {
3581 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
3582 } else {
3583 return PBJ._PBJ.CastUuid();
3584 }
3585 }
3586 set {
3587 super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value));
3588 }
3589 }
3590 public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;}
3591 public const int RequestedObjectLocFieldTag=3;
3592 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
3593 public ObjLoc RequestedObjectLoc{ get {
3594 if (HasRequestedObjectLoc) {
3595 return new ObjLoc(super.RequestedObjectLoc);
3596 } else {
3597 return new ObjLoc();
3598 }
3599 }
3600 set {
3601 super.RequestedObjectLoc=value._PBJSuper;
3602 }
3603 }
3604 public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;}
3605 public const int BoundingSphereFieldTag=4;
3606 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
3607 public PBJ.BoundingSphere3f BoundingSphere{ get {
3608 int index=0;
3609 if (HasBoundingSphere) {
3610 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
3611 } else {
3612 return PBJ._PBJ.CastBoundingsphere3f();
3613 }
3614 }
3615 set {
3616 super.ClearBoundingSphere();
3617 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
3618 super.AddBoundingSphere(_PBJtempArray[0]);
3619 super.AddBoundingSphere(_PBJtempArray[1]);
3620 super.AddBoundingSphere(_PBJtempArray[2]);
3621 super.AddBoundingSphere(_PBJtempArray[3]);
3622 }
3623 }
3624 }
3625 }
3626}
3627namespace Sirikata.Protocol {
3628 public class CreateObject : PBJ.IMessage {
3629 protected _PBJ_Internal.CreateObject super;
3630 public _PBJ_Internal.CreateObject _PBJSuper{ get { return super;} }
3631 public CreateObject() {
3632 super=new _PBJ_Internal.CreateObject();
3633 }
3634 public CreateObject(_PBJ_Internal.CreateObject reference) {
3635 super=reference;
3636 }
3637 public static CreateObject defaultInstance= new CreateObject (_PBJ_Internal.CreateObject.DefaultInstance);
3638 public static CreateObject DefaultInstance{
3639 get {return defaultInstance;}
3640 }
3641 public static pbd.MessageDescriptor Descriptor {
3642 get { return _PBJ_Internal.CreateObject.Descriptor; } }
3643 public static class Types {
3644 }
3645 public static bool WithinReservedFieldTagRange(int field_tag) {
3646 return false;
3647 }
3648 public static bool WithinExtensionFieldTagRange(int field_tag) {
3649 return false;
3650 }
3651 public const int ObjectUuidFieldTag=1;
3652 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
3653 public PBJ.UUID ObjectUuid{ get {
3654 if (HasObjectUuid) {
3655 return PBJ._PBJ.CastUuid(super.ObjectUuid);
3656 } else {
3657 return PBJ._PBJ.CastUuid();
3658 }
3659 }
3660 }
3661 public const int SpacePropertiesFieldTag=2;
3662 public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} }
3663 public bool HasSpaceProperties(int index) {return true;}
3664 public ConnectToSpace SpaceProperties(int index) {
3665 return new ConnectToSpace(super.GetSpaceProperties(index));
3666 }
3667 public const int MeshFieldTag=3;
3668 public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} }
3669 public string Mesh{ get {
3670 if (HasMesh) {
3671 return PBJ._PBJ.CastString(super.Mesh);
3672 } else {
3673 return PBJ._PBJ.CastString();
3674 }
3675 }
3676 }
3677 public const int ScaleFieldTag=4;
3678 public bool HasScale{ get {return super.ScaleCount>=3;} }
3679 public PBJ.Vector3f Scale{ get {
3680 int index=0;
3681 if (HasScale) {
3682 return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2));
3683 } else {
3684 return PBJ._PBJ.CastVector3f();
3685 }
3686 }
3687 }
3688 public const int WeburlFieldTag=5;
3689 public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} }
3690 public string Weburl{ get {
3691 if (HasWeburl) {
3692 return PBJ._PBJ.CastString(super.Weburl);
3693 } else {
3694 return PBJ._PBJ.CastString();
3695 }
3696 }
3697 }
3698 public const int LightInfoFieldTag=6;
3699 public bool HasLightInfo{ get {return super.HasLightInfo;} }
3700 public LightInfoProperty LightInfo{ get {
3701 if (HasLightInfo) {
3702 return new LightInfoProperty(super.LightInfo);
3703 } else {
3704 return new LightInfoProperty();
3705 }
3706 }
3707 }
3708 public const int CameraFieldTag=7;
3709 public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} }
3710 public bool Camera{ get {
3711 if (HasCamera) {
3712 return PBJ._PBJ.CastBool(super.Camera);
3713 } else {
3714 return PBJ._PBJ.CastBool();
3715 }
3716 }
3717 }
3718 public const int PhysicalFieldTag=8;
3719 public bool HasPhysical{ get {return super.HasPhysical;} }
3720 public PhysicalParameters Physical{ get {
3721 if (HasPhysical) {
3722 return new PhysicalParameters(super.Physical);
3723 } else {
3724 return new PhysicalParameters();
3725 }
3726 }
3727 }
3728 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3729 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3730 public static Builder CreateBuilder() { return new Builder(); }
3731 public static Builder CreateBuilder(CreateObject prototype) {
3732 return (Builder)new Builder().MergeFrom(prototype);
3733 }
3734 public static CreateObject ParseFrom(pb::ByteString data) {
3735 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3736 }
3737 public static CreateObject ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3738 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3739 }
3740 public static CreateObject ParseFrom(byte[] data) {
3741 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3742 }
3743 public static CreateObject ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3744 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3745 }
3746 public static CreateObject ParseFrom(global::System.IO.Stream data) {
3747 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3748 }
3749 public static CreateObject ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3750 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3751 }
3752 public static CreateObject ParseFrom(pb::CodedInputStream data) {
3753 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3754 }
3755 public static CreateObject ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3756 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3757 }
3758 protected override bool _HasAllPBJFields{ get {
3759 return true
3760 ;
3761 } }
3762 public bool IsInitialized { get {
3763 return super.IsInitialized&&_HasAllPBJFields;
3764 } }
3765 public class Builder : global::PBJ.IMessage.IBuilder{
3766 protected override bool _HasAllPBJFields{ get {
3767 return true
3768 ;
3769 } }
3770 public bool IsInitialized { get {
3771 return super.IsInitialized&&_HasAllPBJFields;
3772 } }
3773 protected _PBJ_Internal.CreateObject.Builder super;
3774 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3775 public _PBJ_Internal.CreateObject.Builder _PBJSuper{ get { return super;} }
3776 public Builder() {super = new _PBJ_Internal.CreateObject.Builder();}
3777 public Builder(_PBJ_Internal.CreateObject.Builder other) {
3778 super=other;
3779 }
3780 public Builder Clone() {return new Builder(super.Clone());}
3781 public Builder MergeFrom(CreateObject prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3782 public Builder Clear() {super.Clear();return this;}
3783 public CreateObject BuildPartial() {return new CreateObject(super.BuildPartial());}
3784 public CreateObject Build() {if (_HasAllPBJFields) return new CreateObject(super.Build());return null;}
3785 public pbd::MessageDescriptor DescriptorForType {
3786 get { return CreateObject.Descriptor; } }
3787 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
3788 public const int ObjectUuidFieldTag=1;
3789 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
3790 public PBJ.UUID ObjectUuid{ get {
3791 if (HasObjectUuid) {
3792 return PBJ._PBJ.CastUuid(super.ObjectUuid);
3793 } else {
3794 return PBJ._PBJ.CastUuid();
3795 }
3796 }
3797 set {
3798 super.ObjectUuid=(PBJ._PBJ.Construct(value));
3799 }
3800 }
3801 public Builder ClearSpaceProperties() { super.ClearSpaceProperties();return this;}
3802 public Builder SetSpaceProperties(int index,ConnectToSpace value) {
3803 super.SetSpaceProperties(index,value._PBJSuper);
3804 return this;
3805 }
3806 public const int SpacePropertiesFieldTag=2;
3807 public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} }
3808 public bool HasSpaceProperties(int index) {return true;}
3809 public ConnectToSpace SpaceProperties(int index) {
3810 return new ConnectToSpace(super.GetSpaceProperties(index));
3811 }
3812 public Builder AddSpaceProperties(ConnectToSpace value ) {
3813 super.AddSpaceProperties(value._PBJSuper);
3814 return this;
3815 }
3816 public Builder ClearMesh() { super.ClearMesh();return this;}
3817 public const int MeshFieldTag=3;
3818 public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} }
3819 public string Mesh{ get {
3820 if (HasMesh) {
3821 return PBJ._PBJ.CastString(super.Mesh);
3822 } else {
3823 return PBJ._PBJ.CastString();
3824 }
3825 }
3826 set {
3827 super.Mesh=(PBJ._PBJ.Construct(value));
3828 }
3829 }
3830 public Builder ClearScale() { super.ClearScale();return this;}
3831 public const int ScaleFieldTag=4;
3832 public bool HasScale{ get {return super.ScaleCount>=3;} }
3833 public PBJ.Vector3f Scale{ get {
3834 int index=0;
3835 if (HasScale) {
3836 return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2));
3837 } else {
3838 return PBJ._PBJ.CastVector3f();
3839 }
3840 }
3841 set {
3842 super.ClearScale();
3843 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3844 super.AddScale(_PBJtempArray[0]);
3845 super.AddScale(_PBJtempArray[1]);
3846 super.AddScale(_PBJtempArray[2]);
3847 }
3848 }
3849 public Builder ClearWeburl() { super.ClearWeburl();return this;}
3850 public const int WeburlFieldTag=5;
3851 public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} }
3852 public string Weburl{ get {
3853 if (HasWeburl) {
3854 return PBJ._PBJ.CastString(super.Weburl);
3855 } else {
3856 return PBJ._PBJ.CastString();
3857 }
3858 }
3859 set {
3860 super.Weburl=(PBJ._PBJ.Construct(value));
3861 }
3862 }
3863 public Builder ClearLightInfo() { super.ClearLightInfo();return this;}
3864 public const int LightInfoFieldTag=6;
3865 public bool HasLightInfo{ get {return super.HasLightInfo;} }
3866 public LightInfoProperty LightInfo{ get {
3867 if (HasLightInfo) {
3868 return new LightInfoProperty(super.LightInfo);
3869 } else {
3870 return new LightInfoProperty();
3871 }
3872 }
3873 set {
3874 super.LightInfo=value._PBJSuper;
3875 }
3876 }
3877 public Builder ClearCamera() { super.ClearCamera();return this;}
3878 public const int CameraFieldTag=7;
3879 public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} }
3880 public bool Camera{ get {
3881 if (HasCamera) {
3882 return PBJ._PBJ.CastBool(super.Camera);
3883 } else {
3884 return PBJ._PBJ.CastBool();
3885 }
3886 }
3887 set {
3888 super.Camera=(PBJ._PBJ.Construct(value));
3889 }
3890 }
3891 public Builder ClearPhysical() { super.ClearPhysical();return this;}
3892 public const int PhysicalFieldTag=8;
3893 public bool HasPhysical{ get {return super.HasPhysical;} }
3894 public PhysicalParameters Physical{ get {
3895 if (HasPhysical) {
3896 return new PhysicalParameters(super.Physical);
3897 } else {
3898 return new PhysicalParameters();
3899 }
3900 }
3901 set {
3902 super.Physical=value._PBJSuper;
3903 }
3904 }
3905 }
3906 }
3907}
diff --git a/OpenSim/Client/Sirikata/Protocol/Subscription.cs b/OpenSim/Client/Sirikata/Protocol/Subscription.cs
new file mode 100644
index 0000000..06ac8a2
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Subscription.cs
@@ -0,0 +1,856 @@
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2
3using pb = global::Google.ProtocolBuffers;
4using pbc = global::Google.ProtocolBuffers.Collections;
5using pbd = global::Google.ProtocolBuffers.Descriptors;
6using scg = global::System.Collections.Generic;
7namespace 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
new file mode 100644
index 0000000..ca6c7e8
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs
@@ -0,0 +1,404 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.Subscription.Protocol {
4 public class Address : PBJ.IMessage {
5 protected _PBJ_Internal.Address super;
6 public _PBJ_Internal.Address _PBJSuper{ get { return super;} }
7 public Address() {
8 super=new _PBJ_Internal.Address();
9 }
10 public Address(_PBJ_Internal.Address reference) {
11 super=reference;
12 }
13 public static Address defaultInstance= new Address (_PBJ_Internal.Address.DefaultInstance);
14 public static Address DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.Address.Descriptor; } }
19 public static class Types {
20 }
21 public static bool WithinReservedFieldTagRange(int field_tag) {
22 return false;
23 }
24 public static bool WithinExtensionFieldTagRange(int field_tag) {
25 return false;
26 }
27 public const int HostnameFieldTag=1;
28 public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} }
29 public string Hostname{ get {
30 if (HasHostname) {
31 return PBJ._PBJ.CastString(super.Hostname);
32 } else {
33 return PBJ._PBJ.CastString();
34 }
35 }
36 }
37 public const int ServiceFieldTag=2;
38 public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} }
39 public string Service{ get {
40 if (HasService) {
41 return PBJ._PBJ.CastString(super.Service);
42 } else {
43 return PBJ._PBJ.CastString();
44 }
45 }
46 }
47 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
48 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
49 public static Builder CreateBuilder() { return new Builder(); }
50 public static Builder CreateBuilder(Address prototype) {
51 return (Builder)new Builder().MergeFrom(prototype);
52 }
53 public static Address ParseFrom(pb::ByteString data) {
54 return new Address(_PBJ_Internal.Address.ParseFrom(data));
55 }
56 public static Address ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
57 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
58 }
59 public static Address ParseFrom(byte[] data) {
60 return new Address(_PBJ_Internal.Address.ParseFrom(data));
61 }
62 public static Address ParseFrom(byte[] data, pb::ExtensionRegistry er) {
63 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
64 }
65 public static Address ParseFrom(global::System.IO.Stream data) {
66 return new Address(_PBJ_Internal.Address.ParseFrom(data));
67 }
68 public static Address ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
69 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
70 }
71 public static Address ParseFrom(pb::CodedInputStream data) {
72 return new Address(_PBJ_Internal.Address.ParseFrom(data));
73 }
74 public static Address ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
75 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
76 }
77 protected override bool _HasAllPBJFields{ get {
78 return true
79 ;
80 } }
81 public bool IsInitialized { get {
82 return super.IsInitialized&&_HasAllPBJFields;
83 } }
84 public class Builder : global::PBJ.IMessage.IBuilder{
85 protected override bool _HasAllPBJFields{ get {
86 return true
87 ;
88 } }
89 public bool IsInitialized { get {
90 return super.IsInitialized&&_HasAllPBJFields;
91 } }
92 protected _PBJ_Internal.Address.Builder super;
93 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
94 public _PBJ_Internal.Address.Builder _PBJSuper{ get { return super;} }
95 public Builder() {super = new _PBJ_Internal.Address.Builder();}
96 public Builder(_PBJ_Internal.Address.Builder other) {
97 super=other;
98 }
99 public Builder Clone() {return new Builder(super.Clone());}
100 public Builder MergeFrom(Address prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
101 public Builder Clear() {super.Clear();return this;}
102 public Address BuildPartial() {return new Address(super.BuildPartial());}
103 public Address Build() {if (_HasAllPBJFields) return new Address(super.Build());return null;}
104 public pbd::MessageDescriptor DescriptorForType {
105 get { return Address.Descriptor; } }
106 public Builder ClearHostname() { super.ClearHostname();return this;}
107 public const int HostnameFieldTag=1;
108 public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} }
109 public string Hostname{ get {
110 if (HasHostname) {
111 return PBJ._PBJ.CastString(super.Hostname);
112 } else {
113 return PBJ._PBJ.CastString();
114 }
115 }
116 set {
117 super.Hostname=(PBJ._PBJ.Construct(value));
118 }
119 }
120 public Builder ClearService() { super.ClearService();return this;}
121 public const int ServiceFieldTag=2;
122 public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} }
123 public string Service{ get {
124 if (HasService) {
125 return PBJ._PBJ.CastString(super.Service);
126 } else {
127 return PBJ._PBJ.CastString();
128 }
129 }
130 set {
131 super.Service=(PBJ._PBJ.Construct(value));
132 }
133 }
134 }
135 }
136}
137namespace Sirikata.Subscription.Protocol {
138 public class Subscribe : PBJ.IMessage {
139 protected _PBJ_Internal.Subscribe super;
140 public _PBJ_Internal.Subscribe _PBJSuper{ get { return super;} }
141 public Subscribe() {
142 super=new _PBJ_Internal.Subscribe();
143 }
144 public Subscribe(_PBJ_Internal.Subscribe reference) {
145 super=reference;
146 }
147 public static Subscribe defaultInstance= new Subscribe (_PBJ_Internal.Subscribe.DefaultInstance);
148 public static Subscribe DefaultInstance{
149 get {return defaultInstance;}
150 }
151 public static pbd.MessageDescriptor Descriptor {
152 get { return _PBJ_Internal.Subscribe.Descriptor; } }
153 public static class Types {
154 }
155 public static bool WithinReservedFieldTagRange(int field_tag) {
156 return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
157 }
158 public static bool WithinExtensionFieldTagRange(int field_tag) {
159 return false;
160 }
161 public const int BroadcastAddressFieldTag=7;
162 public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} }
163 public Address BroadcastAddress{ get {
164 if (HasBroadcastAddress) {
165 return new Address(super.BroadcastAddress);
166 } else {
167 return new Address();
168 }
169 }
170 }
171 public const int BroadcastNameFieldTag=8;
172 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
173 public PBJ.UUID BroadcastName{ get {
174 if (HasBroadcastName) {
175 return PBJ._PBJ.CastUuid(super.BroadcastName);
176 } else {
177 return PBJ._PBJ.CastUuid();
178 }
179 }
180 }
181 public const int UpdatePeriodFieldTag=9;
182 public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} }
183 public PBJ.Duration UpdatePeriod{ get {
184 if (HasUpdatePeriod) {
185 return PBJ._PBJ.CastDuration(super.UpdatePeriod);
186 } else {
187 return PBJ._PBJ.CastDuration();
188 }
189 }
190 }
191 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
192 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
193 public static Builder CreateBuilder() { return new Builder(); }
194 public static Builder CreateBuilder(Subscribe prototype) {
195 return (Builder)new Builder().MergeFrom(prototype);
196 }
197 public static Subscribe ParseFrom(pb::ByteString data) {
198 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
199 }
200 public static Subscribe ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
201 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
202 }
203 public static Subscribe ParseFrom(byte[] data) {
204 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
205 }
206 public static Subscribe ParseFrom(byte[] data, pb::ExtensionRegistry er) {
207 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
208 }
209 public static Subscribe ParseFrom(global::System.IO.Stream data) {
210 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
211 }
212 public static Subscribe ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
213 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
214 }
215 public static Subscribe ParseFrom(pb::CodedInputStream data) {
216 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
217 }
218 public static Subscribe ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
219 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
220 }
221 protected override bool _HasAllPBJFields{ get {
222 return true
223 ;
224 } }
225 public bool IsInitialized { get {
226 return super.IsInitialized&&_HasAllPBJFields;
227 } }
228 public class Builder : global::PBJ.IMessage.IBuilder{
229 protected override bool _HasAllPBJFields{ get {
230 return true
231 ;
232 } }
233 public bool IsInitialized { get {
234 return super.IsInitialized&&_HasAllPBJFields;
235 } }
236 protected _PBJ_Internal.Subscribe.Builder super;
237 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
238 public _PBJ_Internal.Subscribe.Builder _PBJSuper{ get { return super;} }
239 public Builder() {super = new _PBJ_Internal.Subscribe.Builder();}
240 public Builder(_PBJ_Internal.Subscribe.Builder other) {
241 super=other;
242 }
243 public Builder Clone() {return new Builder(super.Clone());}
244 public Builder MergeFrom(Subscribe prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
245 public Builder Clear() {super.Clear();return this;}
246 public Subscribe BuildPartial() {return new Subscribe(super.BuildPartial());}
247 public Subscribe Build() {if (_HasAllPBJFields) return new Subscribe(super.Build());return null;}
248 public pbd::MessageDescriptor DescriptorForType {
249 get { return Subscribe.Descriptor; } }
250 public Builder ClearBroadcastAddress() { super.ClearBroadcastAddress();return this;}
251 public const int BroadcastAddressFieldTag=7;
252 public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} }
253 public Address BroadcastAddress{ get {
254 if (HasBroadcastAddress) {
255 return new Address(super.BroadcastAddress);
256 } else {
257 return new Address();
258 }
259 }
260 set {
261 super.BroadcastAddress=value._PBJSuper;
262 }
263 }
264 public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;}
265 public const int BroadcastNameFieldTag=8;
266 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
267 public PBJ.UUID BroadcastName{ get {
268 if (HasBroadcastName) {
269 return PBJ._PBJ.CastUuid(super.BroadcastName);
270 } else {
271 return PBJ._PBJ.CastUuid();
272 }
273 }
274 set {
275 super.BroadcastName=(PBJ._PBJ.Construct(value));
276 }
277 }
278 public Builder ClearUpdatePeriod() { super.ClearUpdatePeriod();return this;}
279 public const int UpdatePeriodFieldTag=9;
280 public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} }
281 public PBJ.Duration UpdatePeriod{ get {
282 if (HasUpdatePeriod) {
283 return PBJ._PBJ.CastDuration(super.UpdatePeriod);
284 } else {
285 return PBJ._PBJ.CastDuration();
286 }
287 }
288 set {
289 super.UpdatePeriod=(PBJ._PBJ.Construct(value));
290 }
291 }
292 }
293 }
294}
295namespace Sirikata.Subscription.Protocol {
296 public class Broadcast : PBJ.IMessage {
297 protected _PBJ_Internal.Broadcast super;
298 public _PBJ_Internal.Broadcast _PBJSuper{ get { return super;} }
299 public Broadcast() {
300 super=new _PBJ_Internal.Broadcast();
301 }
302 public Broadcast(_PBJ_Internal.Broadcast reference) {
303 super=reference;
304 }
305 public static Broadcast defaultInstance= new Broadcast (_PBJ_Internal.Broadcast.DefaultInstance);
306 public static Broadcast DefaultInstance{
307 get {return defaultInstance;}
308 }
309 public static pbd.MessageDescriptor Descriptor {
310 get { return _PBJ_Internal.Broadcast.Descriptor; } }
311 public static class Types {
312 }
313 public static bool WithinReservedFieldTagRange(int field_tag) {
314 return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
315 }
316 public static bool WithinExtensionFieldTagRange(int field_tag) {
317 return false;
318 }
319 public const int BroadcastNameFieldTag=7;
320 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
321 public PBJ.UUID BroadcastName{ get {
322 if (HasBroadcastName) {
323 return PBJ._PBJ.CastUuid(super.BroadcastName);
324 } else {
325 return PBJ._PBJ.CastUuid();
326 }
327 }
328 }
329 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
330 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
331 public static Builder CreateBuilder() { return new Builder(); }
332 public static Builder CreateBuilder(Broadcast prototype) {
333 return (Builder)new Builder().MergeFrom(prototype);
334 }
335 public static Broadcast ParseFrom(pb::ByteString data) {
336 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
337 }
338 public static Broadcast ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
339 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
340 }
341 public static Broadcast ParseFrom(byte[] data) {
342 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
343 }
344 public static Broadcast ParseFrom(byte[] data, pb::ExtensionRegistry er) {
345 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
346 }
347 public static Broadcast ParseFrom(global::System.IO.Stream data) {
348 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
349 }
350 public static Broadcast ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
351 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
352 }
353 public static Broadcast ParseFrom(pb::CodedInputStream data) {
354 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
355 }
356 public static Broadcast ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
357 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
358 }
359 protected override bool _HasAllPBJFields{ get {
360 return true
361 ;
362 } }
363 public bool IsInitialized { get {
364 return super.IsInitialized&&_HasAllPBJFields;
365 } }
366 public class Builder : global::PBJ.IMessage.IBuilder{
367 protected override bool _HasAllPBJFields{ get {
368 return true
369 ;
370 } }
371 public bool IsInitialized { get {
372 return super.IsInitialized&&_HasAllPBJFields;
373 } }
374 protected _PBJ_Internal.Broadcast.Builder super;
375 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
376 public _PBJ_Internal.Broadcast.Builder _PBJSuper{ get { return super;} }
377 public Builder() {super = new _PBJ_Internal.Broadcast.Builder();}
378 public Builder(_PBJ_Internal.Broadcast.Builder other) {
379 super=other;
380 }
381 public Builder Clone() {return new Builder(super.Clone());}
382 public Builder MergeFrom(Broadcast prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
383 public Builder Clear() {super.Clear();return this;}
384 public Broadcast BuildPartial() {return new Broadcast(super.BuildPartial());}
385 public Broadcast Build() {if (_HasAllPBJFields) return new Broadcast(super.Build());return null;}
386 public pbd::MessageDescriptor DescriptorForType {
387 get { return Broadcast.Descriptor; } }
388 public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;}
389 public const int BroadcastNameFieldTag=7;
390 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
391 public PBJ.UUID BroadcastName{ get {
392 if (HasBroadcastName) {
393 return PBJ._PBJ.CastUuid(super.BroadcastName);
394 } else {
395 return PBJ._PBJ.CastUuid();
396 }
397 }
398 set {
399 super.BroadcastName=(PBJ._PBJ.Construct(value));
400 }
401 }
402 }
403 }
404}
diff --git a/OpenSim/Client/Sirikata/Protocol/Test.cs b/OpenSim/Client/Sirikata/Protocol/Test.cs
new file mode 100644
index 0000000..0e1372a
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Test.cs
@@ -0,0 +1,3773 @@
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2
3using pb = global::Google.ProtocolBuffers;
4using pbc = global::Google.ProtocolBuffers.Collections;
5using pbd = global::Google.ProtocolBuffers.Descriptors;
6using scg = global::System.Collections.Generic;
7namespace 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
new file mode 100644
index 0000000..c753c36
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs
@@ -0,0 +1,1734 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.PB {
4 public class ExternalMessage : PBJ.IMessage {
5 protected _PBJ_Internal.ExternalMessage super;
6 public _PBJ_Internal.ExternalMessage _PBJSuper{ get { return super;} }
7 public ExternalMessage() {
8 super=new _PBJ_Internal.ExternalMessage();
9 }
10 public ExternalMessage(_PBJ_Internal.ExternalMessage reference) {
11 super=reference;
12 }
13 public static ExternalMessage defaultInstance= new ExternalMessage (_PBJ_Internal.ExternalMessage.DefaultInstance);
14 public static ExternalMessage DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.ExternalMessage.Descriptor; } }
19 public static class Types {
20 public class SubMessage : PBJ.IMessage {
21 protected _PBJ_Internal.ExternalMessage.Types.SubMessage super;
22 public _PBJ_Internal.ExternalMessage.Types.SubMessage _PBJSuper{ get { return super;} }
23 public SubMessage() {
24 super=new _PBJ_Internal.ExternalMessage.Types.SubMessage();
25 }
26 public SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage reference) {
27 super=reference;
28 }
29 public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance);
30 public static SubMessage DefaultInstance{
31 get {return defaultInstance;}
32 }
33 public static pbd.MessageDescriptor Descriptor {
34 get { return _PBJ_Internal.ExternalMessage.Types.SubMessage.Descriptor; } }
35 public static class Types {
36 }
37 public static bool WithinReservedFieldTagRange(int field_tag) {
38 return false;
39 }
40 public static bool WithinExtensionFieldTagRange(int field_tag) {
41 return false;
42 }
43 public const int SubuuidFieldTag=1;
44 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
45 public PBJ.UUID Subuuid{ get {
46 if (HasSubuuid) {
47 return PBJ._PBJ.CastUuid(super.Subuuid);
48 } else {
49 return PBJ._PBJ.CastUuid();
50 }
51 }
52 }
53 public const int SubvectorFieldTag=2;
54 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
55 public PBJ.Vector3d Subvector{ get {
56 int index=0;
57 if (HasSubvector) {
58 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
59 } else {
60 return PBJ._PBJ.CastVector3d();
61 }
62 }
63 }
64 public const int SubdurationFieldTag=3;
65 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
66 public PBJ.Duration Subduration{ get {
67 if (HasSubduration) {
68 return PBJ._PBJ.CastDuration(super.Subduration);
69 } else {
70 return PBJ._PBJ.CastDuration();
71 }
72 }
73 }
74 public const int SubnormalFieldTag=4;
75 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
76 public PBJ.Vector3f Subnormal{ get {
77 int index=0;
78 if (HasSubnormal) {
79 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
80 } else {
81 return PBJ._PBJ.CastNormal();
82 }
83 }
84 }
85 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
86 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
87 public static Builder CreateBuilder() { return new Builder(); }
88 public static Builder CreateBuilder(SubMessage prototype) {
89 return (Builder)new Builder().MergeFrom(prototype);
90 }
91 public static SubMessage ParseFrom(pb::ByteString data) {
92 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
93 }
94 public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
95 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
96 }
97 public static SubMessage ParseFrom(byte[] data) {
98 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
99 }
100 public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
101 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
102 }
103 public static SubMessage ParseFrom(global::System.IO.Stream data) {
104 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
105 }
106 public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
107 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
108 }
109 public static SubMessage ParseFrom(pb::CodedInputStream data) {
110 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
111 }
112 public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
113 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
114 }
115 protected override bool _HasAllPBJFields{ get {
116 return true
117 ;
118 } }
119 public bool IsInitialized { get {
120 return super.IsInitialized&&_HasAllPBJFields;
121 } }
122 public class Builder : global::PBJ.IMessage.IBuilder{
123 protected override bool _HasAllPBJFields{ get {
124 return true
125 ;
126 } }
127 public bool IsInitialized { get {
128 return super.IsInitialized&&_HasAllPBJFields;
129 } }
130 protected _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder super;
131 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
132 public _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} }
133 public Builder() {super = new _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder();}
134 public Builder(_PBJ_Internal.ExternalMessage.Types.SubMessage.Builder other) {
135 super=other;
136 }
137 public Builder Clone() {return new Builder(super.Clone());}
138 public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
139 public Builder Clear() {super.Clear();return this;}
140 public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());}
141 public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;}
142 public pbd::MessageDescriptor DescriptorForType {
143 get { return SubMessage.Descriptor; } }
144 public Builder ClearSubuuid() { super.ClearSubuuid();return this;}
145 public const int SubuuidFieldTag=1;
146 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
147 public PBJ.UUID Subuuid{ get {
148 if (HasSubuuid) {
149 return PBJ._PBJ.CastUuid(super.Subuuid);
150 } else {
151 return PBJ._PBJ.CastUuid();
152 }
153 }
154 set {
155 super.Subuuid=(PBJ._PBJ.Construct(value));
156 }
157 }
158 public Builder ClearSubvector() { super.ClearSubvector();return this;}
159 public const int SubvectorFieldTag=2;
160 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
161 public PBJ.Vector3d Subvector{ get {
162 int index=0;
163 if (HasSubvector) {
164 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
165 } else {
166 return PBJ._PBJ.CastVector3d();
167 }
168 }
169 set {
170 super.ClearSubvector();
171 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
172 super.AddSubvector(_PBJtempArray[0]);
173 super.AddSubvector(_PBJtempArray[1]);
174 super.AddSubvector(_PBJtempArray[2]);
175 }
176 }
177 public Builder ClearSubduration() { super.ClearSubduration();return this;}
178 public const int SubdurationFieldTag=3;
179 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
180 public PBJ.Duration Subduration{ get {
181 if (HasSubduration) {
182 return PBJ._PBJ.CastDuration(super.Subduration);
183 } else {
184 return PBJ._PBJ.CastDuration();
185 }
186 }
187 set {
188 super.Subduration=(PBJ._PBJ.Construct(value));
189 }
190 }
191 public Builder ClearSubnormal() { super.ClearSubnormal();return this;}
192 public const int SubnormalFieldTag=4;
193 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
194 public PBJ.Vector3f Subnormal{ get {
195 int index=0;
196 if (HasSubnormal) {
197 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
198 } else {
199 return PBJ._PBJ.CastNormal();
200 }
201 }
202 set {
203 super.ClearSubnormal();
204 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
205 super.AddSubnormal(_PBJtempArray[0]);
206 super.AddSubnormal(_PBJtempArray[1]);
207 }
208 }
209 }
210 }
211 }
212 public static bool WithinReservedFieldTagRange(int field_tag) {
213 return false;
214 }
215 public static bool WithinExtensionFieldTagRange(int field_tag) {
216 return false;
217 }
218 public const int IsTrueFieldTag=40;
219 public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} }
220 public bool IsTrue{ get {
221 if (HasIsTrue) {
222 return PBJ._PBJ.CastBool(super.IsTrue);
223 } else {
224 return true;
225 }
226 }
227 }
228 public const int V2FFieldTag=2;
229 public bool HasV2F{ get {return super.V2FCount>=2;} }
230 public PBJ.Vector2f V2F{ get {
231 int index=0;
232 if (HasV2F) {
233 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
234 } else {
235 return PBJ._PBJ.CastVector2f();
236 }
237 }
238 }
239 public const int SubMesFieldTag=30;
240 public bool HasSubMes{ get {return super.HasSubMes;} }
241 public Types.SubMessage SubMes{ get {
242 if (HasSubMes) {
243 return new Types.SubMessage(super.SubMes);
244 } else {
245 return new Types.SubMessage();
246 }
247 }
248 }
249 public const int SubmessersFieldTag=31;
250 public int SubmessersCount { get { return super.SubmessersCount;} }
251 public bool HasSubmessers(int index) {return true;}
252 public Types.SubMessage Submessers(int index) {
253 return new Types.SubMessage(super.GetSubmessers(index));
254 }
255 public const int ShaFieldTag=32;
256 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
257 public PBJ.SHA256 Sha{ get {
258 if (HasSha) {
259 return PBJ._PBJ.CastSha256(super.Sha);
260 } else {
261 return PBJ._PBJ.CastSha256();
262 }
263 }
264 }
265 public const int ShasFieldTag=33;
266 public int ShasCount { get { return super.ShasCount;} }
267 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
268 public PBJ.SHA256 Shas(int index) {
269 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
270 }
271 public const int V3FFieldTag=4;
272 public bool HasV3F{ get {return super.V3FCount>=3;} }
273 public PBJ.Vector3f V3F{ get {
274 int index=0;
275 if (HasV3F) {
276 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
277 } else {
278 return PBJ._PBJ.CastVector3f();
279 }
280 }
281 }
282 public const int V3FfFieldTag=5;
283 public int V3FfCount { get { return super.V3FfCount/3;} }
284 public bool HasV3Ff(int index) { return true; }
285 public PBJ.Vector3f GetV3Ff(int index) {
286 if (HasV3Ff(index)) {
287 return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2));
288 } else {
289 return PBJ._PBJ.CastVector3f();
290 }
291 }
292 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
293 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
294 public static Builder CreateBuilder() { return new Builder(); }
295 public static Builder CreateBuilder(ExternalMessage prototype) {
296 return (Builder)new Builder().MergeFrom(prototype);
297 }
298 public static ExternalMessage ParseFrom(pb::ByteString data) {
299 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
300 }
301 public static ExternalMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
302 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
303 }
304 public static ExternalMessage ParseFrom(byte[] data) {
305 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
306 }
307 public static ExternalMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
308 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
309 }
310 public static ExternalMessage ParseFrom(global::System.IO.Stream data) {
311 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
312 }
313 public static ExternalMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
314 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
315 }
316 public static ExternalMessage ParseFrom(pb::CodedInputStream data) {
317 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
318 }
319 public static ExternalMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
320 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
321 }
322 protected override bool _HasAllPBJFields{ get {
323 return true
324 &&HasV3F
325 ;
326 } }
327 public bool IsInitialized { get {
328 return super.IsInitialized&&_HasAllPBJFields;
329 } }
330 public class Builder : global::PBJ.IMessage.IBuilder{
331 protected override bool _HasAllPBJFields{ get {
332 return true
333 &&HasV3F
334 ;
335 } }
336 public bool IsInitialized { get {
337 return super.IsInitialized&&_HasAllPBJFields;
338 } }
339 protected _PBJ_Internal.ExternalMessage.Builder super;
340 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
341 public _PBJ_Internal.ExternalMessage.Builder _PBJSuper{ get { return super;} }
342 public Builder() {super = new _PBJ_Internal.ExternalMessage.Builder();}
343 public Builder(_PBJ_Internal.ExternalMessage.Builder other) {
344 super=other;
345 }
346 public Builder Clone() {return new Builder(super.Clone());}
347 public Builder MergeFrom(ExternalMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
348 public Builder Clear() {super.Clear();return this;}
349 public ExternalMessage BuildPartial() {return new ExternalMessage(super.BuildPartial());}
350 public ExternalMessage Build() {if (_HasAllPBJFields) return new ExternalMessage(super.Build());return null;}
351 public pbd::MessageDescriptor DescriptorForType {
352 get { return ExternalMessage.Descriptor; } }
353 public Builder ClearIsTrue() { super.ClearIsTrue();return this;}
354 public const int IsTrueFieldTag=40;
355 public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} }
356 public bool IsTrue{ get {
357 if (HasIsTrue) {
358 return PBJ._PBJ.CastBool(super.IsTrue);
359 } else {
360 return true;
361 }
362 }
363 set {
364 super.IsTrue=(PBJ._PBJ.Construct(value));
365 }
366 }
367 public Builder ClearV2F() { super.ClearV2F();return this;}
368 public const int V2FFieldTag=2;
369 public bool HasV2F{ get {return super.V2FCount>=2;} }
370 public PBJ.Vector2f V2F{ get {
371 int index=0;
372 if (HasV2F) {
373 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
374 } else {
375 return PBJ._PBJ.CastVector2f();
376 }
377 }
378 set {
379 super.ClearV2F();
380 float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value);
381 super.AddV2F(_PBJtempArray[0]);
382 super.AddV2F(_PBJtempArray[1]);
383 }
384 }
385 public Builder ClearSubMes() { super.ClearSubMes();return this;}
386 public const int SubMesFieldTag=30;
387 public bool HasSubMes{ get {return super.HasSubMes;} }
388 public Types.SubMessage SubMes{ get {
389 if (HasSubMes) {
390 return new Types.SubMessage(super.SubMes);
391 } else {
392 return new Types.SubMessage();
393 }
394 }
395 set {
396 super.SubMes=value._PBJSuper;
397 }
398 }
399 public Builder ClearSubmessers() { super.ClearSubmessers();return this;}
400 public Builder SetSubmessers(int index,Types.SubMessage value) {
401 super.SetSubmessers(index,value._PBJSuper);
402 return this;
403 }
404 public const int SubmessersFieldTag=31;
405 public int SubmessersCount { get { return super.SubmessersCount;} }
406 public bool HasSubmessers(int index) {return true;}
407 public Types.SubMessage Submessers(int index) {
408 return new Types.SubMessage(super.GetSubmessers(index));
409 }
410 public Builder AddSubmessers(Types.SubMessage value ) {
411 super.AddSubmessers(value._PBJSuper);
412 return this;
413 }
414 public Builder ClearSha() { super.ClearSha();return this;}
415 public const int ShaFieldTag=32;
416 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
417 public PBJ.SHA256 Sha{ get {
418 if (HasSha) {
419 return PBJ._PBJ.CastSha256(super.Sha);
420 } else {
421 return PBJ._PBJ.CastSha256();
422 }
423 }
424 set {
425 super.Sha=(PBJ._PBJ.Construct(value));
426 }
427 }
428 public Builder ClearShas() { super.ClearShas();return this;}
429 public Builder SetShas(int index, PBJ.SHA256 value) {
430 super.SetShas(index,PBJ._PBJ.Construct(value));
431 return this;
432 }
433 public const int ShasFieldTag=33;
434 public int ShasCount { get { return super.ShasCount;} }
435 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
436 public PBJ.SHA256 Shas(int index) {
437 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
438 }
439 public Builder AddShas(PBJ.SHA256 value) {
440 super.AddShas(PBJ._PBJ.Construct(value));
441 return this;
442 }
443 public Builder ClearV3F() { super.ClearV3F();return this;}
444 public const int V3FFieldTag=4;
445 public bool HasV3F{ get {return super.V3FCount>=3;} }
446 public PBJ.Vector3f V3F{ get {
447 int index=0;
448 if (HasV3F) {
449 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
450 } else {
451 return PBJ._PBJ.CastVector3f();
452 }
453 }
454 set {
455 super.ClearV3F();
456 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
457 super.AddV3F(_PBJtempArray[0]);
458 super.AddV3F(_PBJtempArray[1]);
459 super.AddV3F(_PBJtempArray[2]);
460 }
461 }
462 public Builder ClearV3Ff() { super.ClearV3Ff();return this;}
463 public const int V3FfFieldTag=5;
464 public int V3FfCount { get { return super.V3FfCount/3;} }
465 public bool HasV3Ff(int index) { return true; }
466 public PBJ.Vector3f GetV3Ff(int index) {
467 if (HasV3Ff(index)) {
468 return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2));
469 } else {
470 return PBJ._PBJ.CastVector3f();
471 }
472 }
473 public Builder AddV3Ff(PBJ.Vector3f value) {
474 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
475 super.AddV3Ff(_PBJtempArray[0]);
476 super.AddV3Ff(_PBJtempArray[1]);
477 super.AddV3Ff(_PBJtempArray[2]);
478 return this;
479 }
480 public Builder SetV3Ff(int index,PBJ.Vector3f value) {
481 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
482 super.SetV3Ff(index*3+0,_PBJtempArray[0]);
483 super.SetV3Ff(index*3+1,_PBJtempArray[1]);
484 super.SetV3Ff(index*3+2,_PBJtempArray[2]);
485 return this;
486 }
487 }
488 }
489}
490namespace Sirikata.PB {
491 public class TestMessage : PBJ.IMessage {
492 protected _PBJ_Internal.TestMessage super;
493 public _PBJ_Internal.TestMessage _PBJSuper{ get { return super;} }
494 public TestMessage() {
495 super=new _PBJ_Internal.TestMessage();
496 }
497 public TestMessage(_PBJ_Internal.TestMessage reference) {
498 super=reference;
499 }
500 public static TestMessage defaultInstance= new TestMessage (_PBJ_Internal.TestMessage.DefaultInstance);
501 public static TestMessage DefaultInstance{
502 get {return defaultInstance;}
503 }
504 public static pbd.MessageDescriptor Descriptor {
505 get { return _PBJ_Internal.TestMessage.Descriptor; } }
506 public static class Types {
507 public enum Flagsf32 {
508 UNIVERSA=_PBJ_Internal.TestMessage.Types.Flagsf32.UNIVERSA,
509 WE=_PBJ_Internal.TestMessage.Types.Flagsf32.WE,
510 IMAGE=_PBJ_Internal.TestMessage.Types.Flagsf32.IMAGE,
511 LOCA=_PBJ_Internal.TestMessage.Types.Flagsf32.LOCA
512 };
513 public enum Flagsf64 {
514 UNIVERSAL=_PBJ_Internal.TestMessage.Types.Flagsf64.UNIVERSAL,
515 WEB=_PBJ_Internal.TestMessage.Types.Flagsf64.WEB,
516 IMAGES=_PBJ_Internal.TestMessage.Types.Flagsf64.IMAGES,
517 LOCAL=_PBJ_Internal.TestMessage.Types.Flagsf64.LOCAL
518 };
519 public enum Enum32 {
520 UNIVERSAL1=_PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1,
521 WEB1=_PBJ_Internal.TestMessage.Types.Enum32.WEB1,
522 IMAGES1=_PBJ_Internal.TestMessage.Types.Enum32.IMAGES1,
523 LOCAL1=_PBJ_Internal.TestMessage.Types.Enum32.LOCAL1
524 };
525 public class SubMessage : PBJ.IMessage {
526 protected _PBJ_Internal.TestMessage.Types.SubMessage super;
527 public _PBJ_Internal.TestMessage.Types.SubMessage _PBJSuper{ get { return super;} }
528 public SubMessage() {
529 super=new _PBJ_Internal.TestMessage.Types.SubMessage();
530 }
531 public SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage reference) {
532 super=reference;
533 }
534 public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance);
535 public static SubMessage DefaultInstance{
536 get {return defaultInstance;}
537 }
538 public static pbd.MessageDescriptor Descriptor {
539 get { return _PBJ_Internal.TestMessage.Types.SubMessage.Descriptor; } }
540 public static class Types {
541 }
542 public static bool WithinReservedFieldTagRange(int field_tag) {
543 return false;
544 }
545 public static bool WithinExtensionFieldTagRange(int field_tag) {
546 return false;
547 }
548 public const int SubuuidFieldTag=1;
549 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
550 public PBJ.UUID Subuuid{ get {
551 if (HasSubuuid) {
552 return PBJ._PBJ.CastUuid(super.Subuuid);
553 } else {
554 return PBJ._PBJ.CastUuid();
555 }
556 }
557 }
558 public const int SubvectorFieldTag=2;
559 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
560 public PBJ.Vector3d Subvector{ get {
561 int index=0;
562 if (HasSubvector) {
563 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
564 } else {
565 return PBJ._PBJ.CastVector3d();
566 }
567 }
568 }
569 public const int SubdurationFieldTag=3;
570 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
571 public PBJ.Duration Subduration{ get {
572 if (HasSubduration) {
573 return PBJ._PBJ.CastDuration(super.Subduration);
574 } else {
575 return PBJ._PBJ.CastDuration();
576 }
577 }
578 }
579 public const int SubnormalFieldTag=4;
580 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
581 public PBJ.Vector3f Subnormal{ get {
582 int index=0;
583 if (HasSubnormal) {
584 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
585 } else {
586 return PBJ._PBJ.CastNormal();
587 }
588 }
589 }
590 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
591 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
592 public static Builder CreateBuilder() { return new Builder(); }
593 public static Builder CreateBuilder(SubMessage prototype) {
594 return (Builder)new Builder().MergeFrom(prototype);
595 }
596 public static SubMessage ParseFrom(pb::ByteString data) {
597 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
598 }
599 public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
600 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
601 }
602 public static SubMessage ParseFrom(byte[] data) {
603 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
604 }
605 public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
606 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
607 }
608 public static SubMessage ParseFrom(global::System.IO.Stream data) {
609 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
610 }
611 public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
612 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
613 }
614 public static SubMessage ParseFrom(pb::CodedInputStream data) {
615 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
616 }
617 public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
618 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
619 }
620 protected override bool _HasAllPBJFields{ get {
621 return true
622 ;
623 } }
624 public bool IsInitialized { get {
625 return super.IsInitialized&&_HasAllPBJFields;
626 } }
627 public class Builder : global::PBJ.IMessage.IBuilder{
628 protected override bool _HasAllPBJFields{ get {
629 return true
630 ;
631 } }
632 public bool IsInitialized { get {
633 return super.IsInitialized&&_HasAllPBJFields;
634 } }
635 protected _PBJ_Internal.TestMessage.Types.SubMessage.Builder super;
636 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
637 public _PBJ_Internal.TestMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} }
638 public Builder() {super = new _PBJ_Internal.TestMessage.Types.SubMessage.Builder();}
639 public Builder(_PBJ_Internal.TestMessage.Types.SubMessage.Builder other) {
640 super=other;
641 }
642 public Builder Clone() {return new Builder(super.Clone());}
643 public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
644 public Builder Clear() {super.Clear();return this;}
645 public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());}
646 public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;}
647 public pbd::MessageDescriptor DescriptorForType {
648 get { return SubMessage.Descriptor; } }
649 public Builder ClearSubuuid() { super.ClearSubuuid();return this;}
650 public const int SubuuidFieldTag=1;
651 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
652 public PBJ.UUID Subuuid{ get {
653 if (HasSubuuid) {
654 return PBJ._PBJ.CastUuid(super.Subuuid);
655 } else {
656 return PBJ._PBJ.CastUuid();
657 }
658 }
659 set {
660 super.Subuuid=(PBJ._PBJ.Construct(value));
661 }
662 }
663 public Builder ClearSubvector() { super.ClearSubvector();return this;}
664 public const int SubvectorFieldTag=2;
665 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
666 public PBJ.Vector3d Subvector{ get {
667 int index=0;
668 if (HasSubvector) {
669 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
670 } else {
671 return PBJ._PBJ.CastVector3d();
672 }
673 }
674 set {
675 super.ClearSubvector();
676 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
677 super.AddSubvector(_PBJtempArray[0]);
678 super.AddSubvector(_PBJtempArray[1]);
679 super.AddSubvector(_PBJtempArray[2]);
680 }
681 }
682 public Builder ClearSubduration() { super.ClearSubduration();return this;}
683 public const int SubdurationFieldTag=3;
684 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
685 public PBJ.Duration Subduration{ get {
686 if (HasSubduration) {
687 return PBJ._PBJ.CastDuration(super.Subduration);
688 } else {
689 return PBJ._PBJ.CastDuration();
690 }
691 }
692 set {
693 super.Subduration=(PBJ._PBJ.Construct(value));
694 }
695 }
696 public Builder ClearSubnormal() { super.ClearSubnormal();return this;}
697 public const int SubnormalFieldTag=4;
698 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
699 public PBJ.Vector3f Subnormal{ get {
700 int index=0;
701 if (HasSubnormal) {
702 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
703 } else {
704 return PBJ._PBJ.CastNormal();
705 }
706 }
707 set {
708 super.ClearSubnormal();
709 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
710 super.AddSubnormal(_PBJtempArray[0]);
711 super.AddSubnormal(_PBJtempArray[1]);
712 }
713 }
714 }
715 }
716 }
717 public static bool WithinReservedFieldTagRange(int field_tag) {
718 return false;
719 }
720 public static bool WithinExtensionFieldTagRange(int field_tag) {
721 return false||(field_tag>=100&&field_tag<=199);
722 }
723 public const int XxdFieldTag=20;
724 public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} }
725 public double Xxd{ get {
726 if (HasXxd) {
727 return PBJ._PBJ.CastDouble(super.Xxd);
728 } else {
729 return 10.3;
730 }
731 }
732 }
733 public const int XxfFieldTag=21;
734 public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} }
735 public float Xxf{ get {
736 if (HasXxf) {
737 return PBJ._PBJ.CastFloat(super.Xxf);
738 } else {
739 return PBJ._PBJ.CastFloat();
740 }
741 }
742 }
743 public const int Xxu32FieldTag=22;
744 public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} }
745 public uint Xxu32{ get {
746 if (HasXxu32) {
747 return PBJ._PBJ.CastUint32(super.Xxu32);
748 } else {
749 return PBJ._PBJ.CastUint32();
750 }
751 }
752 }
753 public const int XxsFieldTag=23;
754 public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} }
755 public string Xxs{ get {
756 if (HasXxs) {
757 return PBJ._PBJ.CastString(super.Xxs);
758 } else {
759 return PBJ._PBJ.CastString();
760 }
761 }
762 }
763 public const int XxbFieldTag=24;
764 public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} }
765 public pb::ByteString Xxb{ get {
766 if (HasXxb) {
767 return PBJ._PBJ.CastBytes(super.Xxb);
768 } else {
769 return PBJ._PBJ.CastBytes();
770 }
771 }
772 }
773 public const int XxssFieldTag=25;
774 public int XxssCount { get { return super.XxssCount;} }
775 public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));}
776 public string Xxss(int index) {
777 return (string)PBJ._PBJ.CastString(super.GetXxss(index));
778 }
779 public const int XxbbFieldTag=26;
780 public int XxbbCount { get { return super.XxbbCount;} }
781 public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));}
782 public pb::ByteString Xxbb(int index) {
783 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index));
784 }
785 public const int XxffFieldTag=27;
786 public int XxffCount { get { return super.XxffCount;} }
787 public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));}
788 public float Xxff(int index) {
789 return (float)PBJ._PBJ.CastFloat(super.GetXxff(index));
790 }
791 public const int XxnnFieldTag=29;
792 public int XxnnCount { get { return super.XxnnCount/2;} }
793 public bool HasXxnn(int index) { return true; }
794 public PBJ.Vector3f GetXxnn(int index) {
795 if (HasXxnn(index)) {
796 return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1));
797 } else {
798 return PBJ._PBJ.CastNormal();
799 }
800 }
801 public const int XxfrFieldTag=28;
802 public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} }
803 public float Xxfr{ get {
804 if (HasXxfr) {
805 return PBJ._PBJ.CastFloat(super.Xxfr);
806 } else {
807 return PBJ._PBJ.CastFloat();
808 }
809 }
810 }
811 public const int NFieldTag=1;
812 public bool HasN{ get {return super.NCount>=2;} }
813 public PBJ.Vector3f N{ get {
814 int index=0;
815 if (HasN) {
816 return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1));
817 } else {
818 return PBJ._PBJ.CastNormal();
819 }
820 }
821 }
822 public const int V2FFieldTag=2;
823 public bool HasV2F{ get {return super.V2FCount>=2;} }
824 public PBJ.Vector2f V2F{ get {
825 int index=0;
826 if (HasV2F) {
827 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
828 } else {
829 return PBJ._PBJ.CastVector2f();
830 }
831 }
832 }
833 public const int V2DFieldTag=3;
834 public bool HasV2D{ get {return super.V2DCount>=2;} }
835 public PBJ.Vector2d V2D{ get {
836 int index=0;
837 if (HasV2D) {
838 return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1));
839 } else {
840 return PBJ._PBJ.CastVector2d();
841 }
842 }
843 }
844 public const int V3FFieldTag=4;
845 public bool HasV3F{ get {return super.V3FCount>=3;} }
846 public PBJ.Vector3f V3F{ get {
847 int index=0;
848 if (HasV3F) {
849 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
850 } else {
851 return PBJ._PBJ.CastVector3f();
852 }
853 }
854 }
855 public const int V3DFieldTag=5;
856 public bool HasV3D{ get {return super.V3DCount>=3;} }
857 public PBJ.Vector3d V3D{ get {
858 int index=0;
859 if (HasV3D) {
860 return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2));
861 } else {
862 return PBJ._PBJ.CastVector3d();
863 }
864 }
865 }
866 public const int V4FFieldTag=6;
867 public bool HasV4F{ get {return super.V4FCount>=4;} }
868 public PBJ.Vector4f V4F{ get {
869 int index=0;
870 if (HasV4F) {
871 return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3));
872 } else {
873 return PBJ._PBJ.CastVector4f();
874 }
875 }
876 }
877 public const int V4DFieldTag=7;
878 public bool HasV4D{ get {return super.V4DCount>=4;} }
879 public PBJ.Vector4d V4D{ get {
880 int index=0;
881 if (HasV4D) {
882 return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3));
883 } else {
884 return PBJ._PBJ.CastVector4d();
885 }
886 }
887 }
888 public const int QFieldTag=8;
889 public bool HasQ{ get {return super.QCount>=3;} }
890 public PBJ.Quaternion Q{ get {
891 int index=0;
892 if (HasQ) {
893 return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2));
894 } else {
895 return PBJ._PBJ.CastQuaternion();
896 }
897 }
898 }
899 public const int UFieldTag=9;
900 public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} }
901 public PBJ.UUID U{ get {
902 if (HasU) {
903 return PBJ._PBJ.CastUuid(super.U);
904 } else {
905 return PBJ._PBJ.CastUuid();
906 }
907 }
908 }
909 public const int AFieldTag=10;
910 public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} }
911 public float A{ get {
912 if (HasA) {
913 return PBJ._PBJ.CastAngle(super.A);
914 } else {
915 return PBJ._PBJ.CastAngle();
916 }
917 }
918 }
919 public const int TFieldTag=11;
920 public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} }
921 public PBJ.Time T{ get {
922 if (HasT) {
923 return PBJ._PBJ.CastTime(super.T);
924 } else {
925 return PBJ._PBJ.CastTime();
926 }
927 }
928 }
929 public const int DFieldTag=12;
930 public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} }
931 public PBJ.Duration D{ get {
932 if (HasD) {
933 return PBJ._PBJ.CastDuration(super.D);
934 } else {
935 return PBJ._PBJ.CastDuration();
936 }
937 }
938 }
939 public const int F32FieldTag=13;
940 public bool HasF32 { get {
941 if (!super.HasF32) return false;
942 return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
943 } }
944 public uint F32{ get {
945 if (HasF32) {
946 return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
947 } else {
948 return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
949 }
950 }
951 }
952 public const int F64FieldTag=14;
953 public bool HasF64 { get {
954 if (!super.HasF64) return false;
955 return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
956 } }
957 public ulong F64{ get {
958 if (HasF64) {
959 return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
960 } else {
961 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
962 }
963 }
964 }
965 public const int BsfFieldTag=15;
966 public bool HasBsf{ get {return super.BsfCount>=4;} }
967 public PBJ.BoundingSphere3f Bsf{ get {
968 int index=0;
969 if (HasBsf) {
970 return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3));
971 } else {
972 return PBJ._PBJ.CastBoundingsphere3f();
973 }
974 }
975 }
976 public const int BsdFieldTag=16;
977 public bool HasBsd{ get {return super.BsdCount>=4;} }
978 public PBJ.BoundingSphere3d Bsd{ get {
979 int index=0;
980 if (HasBsd) {
981 return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3));
982 } else {
983 return PBJ._PBJ.CastBoundingsphere3d();
984 }
985 }
986 }
987 public const int BbfFieldTag=17;
988 public bool HasBbf{ get {return super.BbfCount>=6;} }
989 public PBJ.BoundingBox3f3f Bbf{ get {
990 int index=0;
991 if (HasBbf) {
992 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));
993 } else {
994 return PBJ._PBJ.CastBoundingbox3f3f();
995 }
996 }
997 }
998 public const int BbdFieldTag=18;
999 public bool HasBbd{ get {return super.BbdCount>=6;} }
1000 public PBJ.BoundingBox3d3f Bbd{ get {
1001 int index=0;
1002 if (HasBbd) {
1003 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));
1004 } else {
1005 return PBJ._PBJ.CastBoundingbox3d3f();
1006 }
1007 }
1008 }
1009 public const int E32FieldTag=19;
1010 public bool HasE32{ get {return super.HasE32;} }
1011 public Types.Enum32 E32{ get {
1012 if (HasE32) {
1013 return (Types.Enum32)super.E32;
1014 } else {
1015 return new Types.Enum32();
1016 }
1017 }
1018 }
1019 public const int SubmesFieldTag=30;
1020 public bool HasSubmes{ get {return super.HasSubmes;} }
1021 public Types.SubMessage Submes{ get {
1022 if (HasSubmes) {
1023 return new Types.SubMessage(super.Submes);
1024 } else {
1025 return new Types.SubMessage();
1026 }
1027 }
1028 }
1029 public const int SubmessersFieldTag=31;
1030 public int SubmessersCount { get { return super.SubmessersCount;} }
1031 public bool HasSubmessers(int index) {return true;}
1032 public Types.SubMessage Submessers(int index) {
1033 return new Types.SubMessage(super.GetSubmessers(index));
1034 }
1035 public const int ShaFieldTag=32;
1036 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
1037 public PBJ.SHA256 Sha{ get {
1038 if (HasSha) {
1039 return PBJ._PBJ.CastSha256(super.Sha);
1040 } else {
1041 return PBJ._PBJ.CastSha256();
1042 }
1043 }
1044 }
1045 public const int ShasFieldTag=33;
1046 public int ShasCount { get { return super.ShasCount;} }
1047 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
1048 public PBJ.SHA256 Shas(int index) {
1049 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
1050 }
1051 public const int ExtmesFieldTag=34;
1052 public bool HasExtmes{ get {return super.HasExtmes;} }
1053 public ExternalMessage Extmes{ get {
1054 if (HasExtmes) {
1055 return new ExternalMessage(super.Extmes);
1056 } else {
1057 return new ExternalMessage();
1058 }
1059 }
1060 }
1061 public const int ExtmessersFieldTag=35;
1062 public int ExtmessersCount { get { return super.ExtmessersCount;} }
1063 public bool HasExtmessers(int index) {return true;}
1064 public ExternalMessage Extmessers(int index) {
1065 return new ExternalMessage(super.GetExtmessers(index));
1066 }
1067 public const int ExtmesserFieldTag=36;
1068 public bool HasExtmesser{ get {return super.HasExtmesser;} }
1069 public ExternalMessage Extmesser{ get {
1070 if (HasExtmesser) {
1071 return new ExternalMessage(super.Extmesser);
1072 } else {
1073 return new ExternalMessage();
1074 }
1075 }
1076 }
1077 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1078 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1079 public static Builder CreateBuilder() { return new Builder(); }
1080 public static Builder CreateBuilder(TestMessage prototype) {
1081 return (Builder)new Builder().MergeFrom(prototype);
1082 }
1083 public static TestMessage ParseFrom(pb::ByteString data) {
1084 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1085 }
1086 public static TestMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1087 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1088 }
1089 public static TestMessage ParseFrom(byte[] data) {
1090 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1091 }
1092 public static TestMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1093 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1094 }
1095 public static TestMessage ParseFrom(global::System.IO.Stream data) {
1096 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1097 }
1098 public static TestMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1099 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1100 }
1101 public static TestMessage ParseFrom(pb::CodedInputStream data) {
1102 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1103 }
1104 public static TestMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1105 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1106 }
1107 protected override bool _HasAllPBJFields{ get {
1108 return true
1109 &&HasV3F
1110 ;
1111 } }
1112 public bool IsInitialized { get {
1113 return super.IsInitialized&&_HasAllPBJFields;
1114 } }
1115 public class Builder : global::PBJ.IMessage.IBuilder{
1116 protected override bool _HasAllPBJFields{ get {
1117 return true
1118 &&HasV3F
1119 ;
1120 } }
1121 public bool IsInitialized { get {
1122 return super.IsInitialized&&_HasAllPBJFields;
1123 } }
1124 protected _PBJ_Internal.TestMessage.Builder super;
1125 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1126 public _PBJ_Internal.TestMessage.Builder _PBJSuper{ get { return super;} }
1127 public Builder() {super = new _PBJ_Internal.TestMessage.Builder();}
1128 public Builder(_PBJ_Internal.TestMessage.Builder other) {
1129 super=other;
1130 }
1131 public Builder Clone() {return new Builder(super.Clone());}
1132 public Builder MergeFrom(TestMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1133 public Builder Clear() {super.Clear();return this;}
1134 public TestMessage BuildPartial() {return new TestMessage(super.BuildPartial());}
1135 public TestMessage Build() {if (_HasAllPBJFields) return new TestMessage(super.Build());return null;}
1136 public pbd::MessageDescriptor DescriptorForType {
1137 get { return TestMessage.Descriptor; } }
1138 public Builder ClearXxd() { super.ClearXxd();return this;}
1139 public const int XxdFieldTag=20;
1140 public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} }
1141 public double Xxd{ get {
1142 if (HasXxd) {
1143 return PBJ._PBJ.CastDouble(super.Xxd);
1144 } else {
1145 return 10.3;
1146 }
1147 }
1148 set {
1149 super.Xxd=(PBJ._PBJ.Construct(value));
1150 }
1151 }
1152 public Builder ClearXxf() { super.ClearXxf();return this;}
1153 public const int XxfFieldTag=21;
1154 public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} }
1155 public float Xxf{ get {
1156 if (HasXxf) {
1157 return PBJ._PBJ.CastFloat(super.Xxf);
1158 } else {
1159 return PBJ._PBJ.CastFloat();
1160 }
1161 }
1162 set {
1163 super.Xxf=(PBJ._PBJ.Construct(value));
1164 }
1165 }
1166 public Builder ClearXxu32() { super.ClearXxu32();return this;}
1167 public const int Xxu32FieldTag=22;
1168 public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} }
1169 public uint Xxu32{ get {
1170 if (HasXxu32) {
1171 return PBJ._PBJ.CastUint32(super.Xxu32);
1172 } else {
1173 return PBJ._PBJ.CastUint32();
1174 }
1175 }
1176 set {
1177 super.Xxu32=(PBJ._PBJ.Construct(value));
1178 }
1179 }
1180 public Builder ClearXxs() { super.ClearXxs();return this;}
1181 public const int XxsFieldTag=23;
1182 public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} }
1183 public string Xxs{ get {
1184 if (HasXxs) {
1185 return PBJ._PBJ.CastString(super.Xxs);
1186 } else {
1187 return PBJ._PBJ.CastString();
1188 }
1189 }
1190 set {
1191 super.Xxs=(PBJ._PBJ.Construct(value));
1192 }
1193 }
1194 public Builder ClearXxb() { super.ClearXxb();return this;}
1195 public const int XxbFieldTag=24;
1196 public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} }
1197 public pb::ByteString Xxb{ get {
1198 if (HasXxb) {
1199 return PBJ._PBJ.CastBytes(super.Xxb);
1200 } else {
1201 return PBJ._PBJ.CastBytes();
1202 }
1203 }
1204 set {
1205 super.Xxb=(PBJ._PBJ.Construct(value));
1206 }
1207 }
1208 public Builder ClearXxss() { super.ClearXxss();return this;}
1209 public Builder SetXxss(int index, string value) {
1210 super.SetXxss(index,PBJ._PBJ.Construct(value));
1211 return this;
1212 }
1213 public const int XxssFieldTag=25;
1214 public int XxssCount { get { return super.XxssCount;} }
1215 public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));}
1216 public string Xxss(int index) {
1217 return (string)PBJ._PBJ.CastString(super.GetXxss(index));
1218 }
1219 public Builder AddXxss(string value) {
1220 super.AddXxss(PBJ._PBJ.Construct(value));
1221 return this;
1222 }
1223 public Builder ClearXxbb() { super.ClearXxbb();return this;}
1224 public Builder SetXxbb(int index, pb::ByteString value) {
1225 super.SetXxbb(index,PBJ._PBJ.Construct(value));
1226 return this;
1227 }
1228 public const int XxbbFieldTag=26;
1229 public int XxbbCount { get { return super.XxbbCount;} }
1230 public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));}
1231 public pb::ByteString Xxbb(int index) {
1232 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index));
1233 }
1234 public Builder AddXxbb(pb::ByteString value) {
1235 super.AddXxbb(PBJ._PBJ.Construct(value));
1236 return this;
1237 }
1238 public Builder ClearXxff() { super.ClearXxff();return this;}
1239 public Builder SetXxff(int index, float value) {
1240 super.SetXxff(index,PBJ._PBJ.Construct(value));
1241 return this;
1242 }
1243 public const int XxffFieldTag=27;
1244 public int XxffCount { get { return super.XxffCount;} }
1245 public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));}
1246 public float Xxff(int index) {
1247 return (float)PBJ._PBJ.CastFloat(super.GetXxff(index));
1248 }
1249 public Builder AddXxff(float value) {
1250 super.AddXxff(PBJ._PBJ.Construct(value));
1251 return this;
1252 }
1253 public Builder ClearXxnn() { super.ClearXxnn();return this;}
1254 public const int XxnnFieldTag=29;
1255 public int XxnnCount { get { return super.XxnnCount/2;} }
1256 public bool HasXxnn(int index) { return true; }
1257 public PBJ.Vector3f GetXxnn(int index) {
1258 if (HasXxnn(index)) {
1259 return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1));
1260 } else {
1261 return PBJ._PBJ.CastNormal();
1262 }
1263 }
1264 public Builder AddXxnn(PBJ.Vector3f value) {
1265 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1266 super.AddXxnn(_PBJtempArray[0]);
1267 super.AddXxnn(_PBJtempArray[1]);
1268 return this;
1269 }
1270 public Builder SetXxnn(int index,PBJ.Vector3f value) {
1271 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1272 super.SetXxnn(index*2+0,_PBJtempArray[0]);
1273 super.SetXxnn(index*2+1,_PBJtempArray[1]);
1274 return this;
1275 }
1276 public Builder ClearXxfr() { super.ClearXxfr();return this;}
1277 public const int XxfrFieldTag=28;
1278 public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} }
1279 public float Xxfr{ get {
1280 if (HasXxfr) {
1281 return PBJ._PBJ.CastFloat(super.Xxfr);
1282 } else {
1283 return PBJ._PBJ.CastFloat();
1284 }
1285 }
1286 set {
1287 super.Xxfr=(PBJ._PBJ.Construct(value));
1288 }
1289 }
1290 public Builder ClearN() { super.ClearN();return this;}
1291 public const int NFieldTag=1;
1292 public bool HasN{ get {return super.NCount>=2;} }
1293 public PBJ.Vector3f N{ get {
1294 int index=0;
1295 if (HasN) {
1296 return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1));
1297 } else {
1298 return PBJ._PBJ.CastNormal();
1299 }
1300 }
1301 set {
1302 super.ClearN();
1303 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1304 super.AddN(_PBJtempArray[0]);
1305 super.AddN(_PBJtempArray[1]);
1306 }
1307 }
1308 public Builder ClearV2F() { super.ClearV2F();return this;}
1309 public const int V2FFieldTag=2;
1310 public bool HasV2F{ get {return super.V2FCount>=2;} }
1311 public PBJ.Vector2f V2F{ get {
1312 int index=0;
1313 if (HasV2F) {
1314 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
1315 } else {
1316 return PBJ._PBJ.CastVector2f();
1317 }
1318 }
1319 set {
1320 super.ClearV2F();
1321 float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value);
1322 super.AddV2F(_PBJtempArray[0]);
1323 super.AddV2F(_PBJtempArray[1]);
1324 }
1325 }
1326 public Builder ClearV2D() { super.ClearV2D();return this;}
1327 public const int V2DFieldTag=3;
1328 public bool HasV2D{ get {return super.V2DCount>=2;} }
1329 public PBJ.Vector2d V2D{ get {
1330 int index=0;
1331 if (HasV2D) {
1332 return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1));
1333 } else {
1334 return PBJ._PBJ.CastVector2d();
1335 }
1336 }
1337 set {
1338 super.ClearV2D();
1339 double[] _PBJtempArray=PBJ._PBJ.ConstructVector2d(value);
1340 super.AddV2D(_PBJtempArray[0]);
1341 super.AddV2D(_PBJtempArray[1]);
1342 }
1343 }
1344 public Builder ClearV3F() { super.ClearV3F();return this;}
1345 public const int V3FFieldTag=4;
1346 public bool HasV3F{ get {return super.V3FCount>=3;} }
1347 public PBJ.Vector3f V3F{ get {
1348 int index=0;
1349 if (HasV3F) {
1350 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
1351 } else {
1352 return PBJ._PBJ.CastVector3f();
1353 }
1354 }
1355 set {
1356 super.ClearV3F();
1357 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
1358 super.AddV3F(_PBJtempArray[0]);
1359 super.AddV3F(_PBJtempArray[1]);
1360 super.AddV3F(_PBJtempArray[2]);
1361 }
1362 }
1363 public Builder ClearV3D() { super.ClearV3D();return this;}
1364 public const int V3DFieldTag=5;
1365 public bool HasV3D{ get {return super.V3DCount>=3;} }
1366 public PBJ.Vector3d V3D{ get {
1367 int index=0;
1368 if (HasV3D) {
1369 return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2));
1370 } else {
1371 return PBJ._PBJ.CastVector3d();
1372 }
1373 }
1374 set {
1375 super.ClearV3D();
1376 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
1377 super.AddV3D(_PBJtempArray[0]);
1378 super.AddV3D(_PBJtempArray[1]);
1379 super.AddV3D(_PBJtempArray[2]);
1380 }
1381 }
1382 public Builder ClearV4F() { super.ClearV4F();return this;}
1383 public const int V4FFieldTag=6;
1384 public bool HasV4F{ get {return super.V4FCount>=4;} }
1385 public PBJ.Vector4f V4F{ get {
1386 int index=0;
1387 if (HasV4F) {
1388 return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3));
1389 } else {
1390 return PBJ._PBJ.CastVector4f();
1391 }
1392 }
1393 set {
1394 super.ClearV4F();
1395 float[] _PBJtempArray=PBJ._PBJ.ConstructVector4f(value);
1396 super.AddV4F(_PBJtempArray[0]);
1397 super.AddV4F(_PBJtempArray[1]);
1398 super.AddV4F(_PBJtempArray[2]);
1399 super.AddV4F(_PBJtempArray[3]);
1400 }
1401 }
1402 public Builder ClearV4D() { super.ClearV4D();return this;}
1403 public const int V4DFieldTag=7;
1404 public bool HasV4D{ get {return super.V4DCount>=4;} }
1405 public PBJ.Vector4d V4D{ get {
1406 int index=0;
1407 if (HasV4D) {
1408 return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3));
1409 } else {
1410 return PBJ._PBJ.CastVector4d();
1411 }
1412 }
1413 set {
1414 super.ClearV4D();
1415 double[] _PBJtempArray=PBJ._PBJ.ConstructVector4d(value);
1416 super.AddV4D(_PBJtempArray[0]);
1417 super.AddV4D(_PBJtempArray[1]);
1418 super.AddV4D(_PBJtempArray[2]);
1419 super.AddV4D(_PBJtempArray[3]);
1420 }
1421 }
1422 public Builder ClearQ() { super.ClearQ();return this;}
1423 public const int QFieldTag=8;
1424 public bool HasQ{ get {return super.QCount>=3;} }
1425 public PBJ.Quaternion Q{ get {
1426 int index=0;
1427 if (HasQ) {
1428 return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2));
1429 } else {
1430 return PBJ._PBJ.CastQuaternion();
1431 }
1432 }
1433 set {
1434 super.ClearQ();
1435 float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value);
1436 super.AddQ(_PBJtempArray[0]);
1437 super.AddQ(_PBJtempArray[1]);
1438 super.AddQ(_PBJtempArray[2]);
1439 }
1440 }
1441 public Builder ClearU() { super.ClearU();return this;}
1442 public const int UFieldTag=9;
1443 public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} }
1444 public PBJ.UUID U{ get {
1445 if (HasU) {
1446 return PBJ._PBJ.CastUuid(super.U);
1447 } else {
1448 return PBJ._PBJ.CastUuid();
1449 }
1450 }
1451 set {
1452 super.U=(PBJ._PBJ.Construct(value));
1453 }
1454 }
1455 public Builder ClearA() { super.ClearA();return this;}
1456 public const int AFieldTag=10;
1457 public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} }
1458 public float A{ get {
1459 if (HasA) {
1460 return PBJ._PBJ.CastAngle(super.A);
1461 } else {
1462 return PBJ._PBJ.CastAngle();
1463 }
1464 }
1465 set {
1466 super.A=(PBJ._PBJ.Construct(value));
1467 }
1468 }
1469 public Builder ClearT() { super.ClearT();return this;}
1470 public const int TFieldTag=11;
1471 public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} }
1472 public PBJ.Time T{ get {
1473 if (HasT) {
1474 return PBJ._PBJ.CastTime(super.T);
1475 } else {
1476 return PBJ._PBJ.CastTime();
1477 }
1478 }
1479 set {
1480 super.T=(PBJ._PBJ.Construct(value));
1481 }
1482 }
1483 public Builder ClearD() { super.ClearD();return this;}
1484 public const int DFieldTag=12;
1485 public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} }
1486 public PBJ.Duration D{ get {
1487 if (HasD) {
1488 return PBJ._PBJ.CastDuration(super.D);
1489 } else {
1490 return PBJ._PBJ.CastDuration();
1491 }
1492 }
1493 set {
1494 super.D=(PBJ._PBJ.Construct(value));
1495 }
1496 }
1497 public Builder ClearF32() { super.ClearF32();return this;}
1498 public const int F32FieldTag=13;
1499 public bool HasF32 { get {
1500 if (!super.HasF32) return false;
1501 return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
1502 } }
1503 public uint F32{ get {
1504 if (HasF32) {
1505 return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
1506 } else {
1507 return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
1508 }
1509 }
1510 set {
1511 super.F32=((value));
1512 }
1513 }
1514 public Builder ClearF64() { super.ClearF64();return this;}
1515 public const int F64FieldTag=14;
1516 public bool HasF64 { get {
1517 if (!super.HasF64) return false;
1518 return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
1519 } }
1520 public ulong F64{ get {
1521 if (HasF64) {
1522 return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
1523 } else {
1524 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
1525 }
1526 }
1527 set {
1528 super.F64=((value));
1529 }
1530 }
1531 public Builder ClearBsf() { super.ClearBsf();return this;}
1532 public const int BsfFieldTag=15;
1533 public bool HasBsf{ get {return super.BsfCount>=4;} }
1534 public PBJ.BoundingSphere3f Bsf{ get {
1535 int index=0;
1536 if (HasBsf) {
1537 return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3));
1538 } else {
1539 return PBJ._PBJ.CastBoundingsphere3f();
1540 }
1541 }
1542 set {
1543 super.ClearBsf();
1544 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
1545 super.AddBsf(_PBJtempArray[0]);
1546 super.AddBsf(_PBJtempArray[1]);
1547 super.AddBsf(_PBJtempArray[2]);
1548 super.AddBsf(_PBJtempArray[3]);
1549 }
1550 }
1551 public Builder ClearBsd() { super.ClearBsd();return this;}
1552 public const int BsdFieldTag=16;
1553 public bool HasBsd{ get {return super.BsdCount>=4;} }
1554 public PBJ.BoundingSphere3d Bsd{ get {
1555 int index=0;
1556 if (HasBsd) {
1557 return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3));
1558 } else {
1559 return PBJ._PBJ.CastBoundingsphere3d();
1560 }
1561 }
1562 set {
1563 super.ClearBsd();
1564 double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3d(value);
1565 super.AddBsd(_PBJtempArray[0]);
1566 super.AddBsd(_PBJtempArray[1]);
1567 super.AddBsd(_PBJtempArray[2]);
1568 super.AddBsd(_PBJtempArray[3]);
1569 }
1570 }
1571 public Builder ClearBbf() { super.ClearBbf();return this;}
1572 public const int BbfFieldTag=17;
1573 public bool HasBbf{ get {return super.BbfCount>=6;} }
1574 public PBJ.BoundingBox3f3f Bbf{ get {
1575 int index=0;
1576 if (HasBbf) {
1577 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));
1578 } else {
1579 return PBJ._PBJ.CastBoundingbox3f3f();
1580 }
1581 }
1582 set {
1583 super.ClearBbf();
1584 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3f3f(value);
1585 super.AddBbf(_PBJtempArray[0]);
1586 super.AddBbf(_PBJtempArray[1]);
1587 super.AddBbf(_PBJtempArray[2]);
1588 super.AddBbf(_PBJtempArray[3]);
1589 super.AddBbf(_PBJtempArray[4]);
1590 super.AddBbf(_PBJtempArray[5]);
1591 }
1592 }
1593 public Builder ClearBbd() { super.ClearBbd();return this;}
1594 public const int BbdFieldTag=18;
1595 public bool HasBbd{ get {return super.BbdCount>=6;} }
1596 public PBJ.BoundingBox3d3f Bbd{ get {
1597 int index=0;
1598 if (HasBbd) {
1599 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));
1600 } else {
1601 return PBJ._PBJ.CastBoundingbox3d3f();
1602 }
1603 }
1604 set {
1605 super.ClearBbd();
1606 double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3d3f(value);
1607 super.AddBbd(_PBJtempArray[0]);
1608 super.AddBbd(_PBJtempArray[1]);
1609 super.AddBbd(_PBJtempArray[2]);
1610 super.AddBbd(_PBJtempArray[3]);
1611 super.AddBbd(_PBJtempArray[4]);
1612 super.AddBbd(_PBJtempArray[5]);
1613 }
1614 }
1615 public Builder ClearE32() { super.ClearE32();return this;}
1616 public const int E32FieldTag=19;
1617 public bool HasE32{ get {return super.HasE32;} }
1618 public Types.Enum32 E32{ get {
1619 if (HasE32) {
1620 return (Types.Enum32)super.E32;
1621 } else {
1622 return new Types.Enum32();
1623 }
1624 }
1625 set {
1626 super.E32=((_PBJ_Internal.TestMessage.Types.Enum32)value);
1627 }
1628 }
1629 public Builder ClearSubmes() { super.ClearSubmes();return this;}
1630 public const int SubmesFieldTag=30;
1631 public bool HasSubmes{ get {return super.HasSubmes;} }
1632 public Types.SubMessage Submes{ get {
1633 if (HasSubmes) {
1634 return new Types.SubMessage(super.Submes);
1635 } else {
1636 return new Types.SubMessage();
1637 }
1638 }
1639 set {
1640 super.Submes=value._PBJSuper;
1641 }
1642 }
1643 public Builder ClearSubmessers() { super.ClearSubmessers();return this;}
1644 public Builder SetSubmessers(int index,Types.SubMessage value) {
1645 super.SetSubmessers(index,value._PBJSuper);
1646 return this;
1647 }
1648 public const int SubmessersFieldTag=31;
1649 public int SubmessersCount { get { return super.SubmessersCount;} }
1650 public bool HasSubmessers(int index) {return true;}
1651 public Types.SubMessage Submessers(int index) {
1652 return new Types.SubMessage(super.GetSubmessers(index));
1653 }
1654 public Builder AddSubmessers(Types.SubMessage value ) {
1655 super.AddSubmessers(value._PBJSuper);
1656 return this;
1657 }
1658 public Builder ClearSha() { super.ClearSha();return this;}
1659 public const int ShaFieldTag=32;
1660 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
1661 public PBJ.SHA256 Sha{ get {
1662 if (HasSha) {
1663 return PBJ._PBJ.CastSha256(super.Sha);
1664 } else {
1665 return PBJ._PBJ.CastSha256();
1666 }
1667 }
1668 set {
1669 super.Sha=(PBJ._PBJ.Construct(value));
1670 }
1671 }
1672 public Builder ClearShas() { super.ClearShas();return this;}
1673 public Builder SetShas(int index, PBJ.SHA256 value) {
1674 super.SetShas(index,PBJ._PBJ.Construct(value));
1675 return this;
1676 }
1677 public const int ShasFieldTag=33;
1678 public int ShasCount { get { return super.ShasCount;} }
1679 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
1680 public PBJ.SHA256 Shas(int index) {
1681 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
1682 }
1683 public Builder AddShas(PBJ.SHA256 value) {
1684 super.AddShas(PBJ._PBJ.Construct(value));
1685 return this;
1686 }
1687 public Builder ClearExtmes() { super.ClearExtmes();return this;}
1688 public const int ExtmesFieldTag=34;
1689 public bool HasExtmes{ get {return super.HasExtmes;} }
1690 public ExternalMessage Extmes{ get {
1691 if (HasExtmes) {
1692 return new ExternalMessage(super.Extmes);
1693 } else {
1694 return new ExternalMessage();
1695 }
1696 }
1697 set {
1698 super.Extmes=value._PBJSuper;
1699 }
1700 }
1701 public Builder ClearExtmessers() { super.ClearExtmessers();return this;}
1702 public Builder SetExtmessers(int index,ExternalMessage value) {
1703 super.SetExtmessers(index,value._PBJSuper);
1704 return this;
1705 }
1706 public const int ExtmessersFieldTag=35;
1707 public int ExtmessersCount { get { return super.ExtmessersCount;} }
1708 public bool HasExtmessers(int index) {return true;}
1709 public ExternalMessage Extmessers(int index) {
1710 return new ExternalMessage(super.GetExtmessers(index));
1711 }
1712 public Builder AddExtmessers(ExternalMessage value ) {
1713 super.AddExtmessers(value._PBJSuper);
1714 return this;
1715 }
1716 public Builder ClearExtmesser() { super.ClearExtmesser();return this;}
1717 public const int ExtmesserFieldTag=36;
1718 public bool HasExtmesser{ get {return super.HasExtmesser;} }
1719 public ExternalMessage Extmesser{ get {
1720 if (HasExtmesser) {
1721 return new ExternalMessage(super.Extmesser);
1722 } else {
1723 return new ExternalMessage();
1724 }
1725 }
1726 set {
1727 super.Extmesser=value._PBJSuper;
1728 }
1729 }
1730 }
1731 }
1732}
1733namespace Sirikata.PB {
1734}
diff --git a/OpenSim/Client/Sirikata/Protocol/Time.cs b/OpenSim/Client/Sirikata/Protocol/Time.cs
new file mode 100644
index 0000000..4ad49cc
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Time.cs
@@ -0,0 +1,454 @@
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2
3using pb = global::Google.ProtocolBuffers;
4using pbc = global::Google.ProtocolBuffers.Collections;
5using pbd = global::Google.ProtocolBuffers.Descriptors;
6using scg = global::System.Collections.Generic;
7namespace 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
new file mode 100644
index 0000000..c3e9e73
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Time.pbj.cs
@@ -0,0 +1,218 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.Network.Protocol {
4 public class TimeSync : PBJ.IMessage {
5 protected _PBJ_Internal.TimeSync super;
6 public _PBJ_Internal.TimeSync _PBJSuper{ get { return super;} }
7 public TimeSync() {
8 super=new _PBJ_Internal.TimeSync();
9 }
10 public TimeSync(_PBJ_Internal.TimeSync reference) {
11 super=reference;
12 }
13 public static TimeSync defaultInstance= new TimeSync (_PBJ_Internal.TimeSync.DefaultInstance);
14 public static TimeSync DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.TimeSync.Descriptor; } }
19 public static class Types {
20 public enum ReturnOptions {
21 REPLY_RELIABLE=_PBJ_Internal.TimeSync.Types.ReturnOptions.REPLY_RELIABLE,
22 REPLY_ORDERED=_PBJ_Internal.TimeSync.Types.ReturnOptions.REPLY_ORDERED
23 };
24 }
25 public static bool WithinReservedFieldTagRange(int field_tag) {
26 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
27 }
28 public static bool WithinExtensionFieldTagRange(int field_tag) {
29 return false;
30 }
31 public const int ClientTimeFieldTag=9;
32 public bool HasClientTime{ get {return super.HasClientTime&&PBJ._PBJ.ValidateTime(super.ClientTime);} }
33 public PBJ.Time ClientTime{ get {
34 if (HasClientTime) {
35 return PBJ._PBJ.CastTime(super.ClientTime);
36 } else {
37 return PBJ._PBJ.CastTime();
38 }
39 }
40 }
41 public const int ServerTimeFieldTag=10;
42 public bool HasServerTime{ get {return super.HasServerTime&&PBJ._PBJ.ValidateTime(super.ServerTime);} }
43 public PBJ.Time ServerTime{ get {
44 if (HasServerTime) {
45 return PBJ._PBJ.CastTime(super.ServerTime);
46 } else {
47 return PBJ._PBJ.CastTime();
48 }
49 }
50 }
51 public const int SyncRoundFieldTag=11;
52 public bool HasSyncRound{ get {return super.HasSyncRound&&PBJ._PBJ.ValidateUint64(super.SyncRound);} }
53 public ulong SyncRound{ get {
54 if (HasSyncRound) {
55 return PBJ._PBJ.CastUint64(super.SyncRound);
56 } else {
57 return PBJ._PBJ.CastUint64();
58 }
59 }
60 }
61 public const int ReturnOptionsFieldTag=14;
62 public bool HasReturnOptions { get {
63 if (!super.HasReturnOptions) return false;
64 return PBJ._PBJ.ValidateFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED);
65 } }
66 public uint ReturnOptions{ get {
67 if (HasReturnOptions) {
68 return (uint)PBJ._PBJ.CastFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED);
69 } else {
70 return (uint)PBJ._PBJ.CastFlags((ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED);
71 }
72 }
73 }
74 public const int RoundTripFieldTag=2561;
75 public bool HasRoundTrip{ get {return super.HasRoundTrip&&PBJ._PBJ.ValidateTime(super.RoundTrip);} }
76 public PBJ.Time RoundTrip{ get {
77 if (HasRoundTrip) {
78 return PBJ._PBJ.CastTime(super.RoundTrip);
79 } else {
80 return PBJ._PBJ.CastTime();
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(TimeSync prototype) {
88 return (Builder)new Builder().MergeFrom(prototype);
89 }
90 public static TimeSync ParseFrom(pb::ByteString data) {
91 return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data));
92 }
93 public static TimeSync ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
94 return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er));
95 }
96 public static TimeSync ParseFrom(byte[] data) {
97 return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data));
98 }
99 public static TimeSync ParseFrom(byte[] data, pb::ExtensionRegistry er) {
100 return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er));
101 }
102 public static TimeSync ParseFrom(global::System.IO.Stream data) {
103 return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data));
104 }
105 public static TimeSync ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
106 return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data,er));
107 }
108 public static TimeSync ParseFrom(pb::CodedInputStream data) {
109 return new TimeSync(_PBJ_Internal.TimeSync.ParseFrom(data));
110 }
111 public static TimeSync ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
112 return new TimeSync(_PBJ_Internal.TimeSync.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.TimeSync.Builder super;
130 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
131 public _PBJ_Internal.TimeSync.Builder _PBJSuper{ get { return super;} }
132 public Builder() {super = new _PBJ_Internal.TimeSync.Builder();}
133 public Builder(_PBJ_Internal.TimeSync.Builder other) {
134 super=other;
135 }
136 public Builder Clone() {return new Builder(super.Clone());}
137 public Builder MergeFrom(TimeSync prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
138 public Builder Clear() {super.Clear();return this;}
139 public TimeSync BuildPartial() {return new TimeSync(super.BuildPartial());}
140 public TimeSync Build() {if (_HasAllPBJFields) return new TimeSync(super.Build());return null;}
141 public pbd::MessageDescriptor DescriptorForType {
142 get { return TimeSync.Descriptor; } }
143 public Builder ClearClientTime() { super.ClearClientTime();return this;}
144 public const int ClientTimeFieldTag=9;
145 public bool HasClientTime{ get {return super.HasClientTime&&PBJ._PBJ.ValidateTime(super.ClientTime);} }
146 public PBJ.Time ClientTime{ get {
147 if (HasClientTime) {
148 return PBJ._PBJ.CastTime(super.ClientTime);
149 } else {
150 return PBJ._PBJ.CastTime();
151 }
152 }
153 set {
154 super.ClientTime=(PBJ._PBJ.Construct(value));
155 }
156 }
157 public Builder ClearServerTime() { super.ClearServerTime();return this;}
158 public const int ServerTimeFieldTag=10;
159 public bool HasServerTime{ get {return super.HasServerTime&&PBJ._PBJ.ValidateTime(super.ServerTime);} }
160 public PBJ.Time ServerTime{ get {
161 if (HasServerTime) {
162 return PBJ._PBJ.CastTime(super.ServerTime);
163 } else {
164 return PBJ._PBJ.CastTime();
165 }
166 }
167 set {
168 super.ServerTime=(PBJ._PBJ.Construct(value));
169 }
170 }
171 public Builder ClearSyncRound() { super.ClearSyncRound();return this;}
172 public const int SyncRoundFieldTag=11;
173 public bool HasSyncRound{ get {return super.HasSyncRound&&PBJ._PBJ.ValidateUint64(super.SyncRound);} }
174 public ulong SyncRound{ get {
175 if (HasSyncRound) {
176 return PBJ._PBJ.CastUint64(super.SyncRound);
177 } else {
178 return PBJ._PBJ.CastUint64();
179 }
180 }
181 set {
182 super.SyncRound=(PBJ._PBJ.Construct(value));
183 }
184 }
185 public Builder ClearReturnOptions() { super.ClearReturnOptions();return this;}
186 public const int ReturnOptionsFieldTag=14;
187 public bool HasReturnOptions { get {
188 if (!super.HasReturnOptions) return false;
189 return PBJ._PBJ.ValidateFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED);
190 } }
191 public uint ReturnOptions{ get {
192 if (HasReturnOptions) {
193 return (uint)PBJ._PBJ.CastFlags(super.ReturnOptions,(ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED);
194 } else {
195 return (uint)PBJ._PBJ.CastFlags((ulong)Types.ReturnOptions.REPLY_RELIABLE|(ulong)Types.ReturnOptions.REPLY_ORDERED);
196 }
197 }
198 set {
199 super.ReturnOptions=((value));
200 }
201 }
202 public Builder ClearRoundTrip() { super.ClearRoundTrip();return this;}
203 public const int RoundTripFieldTag=2561;
204 public bool HasRoundTrip{ get {return super.HasRoundTrip&&PBJ._PBJ.ValidateTime(super.RoundTrip);} }
205 public PBJ.Time RoundTrip{ get {
206 if (HasRoundTrip) {
207 return PBJ._PBJ.CastTime(super.RoundTrip);
208 } else {
209 return PBJ._PBJ.CastTime();
210 }
211 }
212 set {
213 super.RoundTrip=(PBJ._PBJ.Construct(value));
214 }
215 }
216 }
217 }
218}