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