aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Client/Sirikata/Protocol/Test.pbj.cs')
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Test.pbj.cs1761
1 files changed, 0 insertions, 1761 deletions
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}
generated by cgit v1.1 at 2024-11-17 09:46:25 +0000