aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs
diff options
context:
space:
mode:
authorMelanie2009-12-27 15:49:09 +0000
committerMelanie2009-12-27 15:49:09 +0000
commit769dad278373c0b945aa01a75365c0d658c98540 (patch)
tree601347095dd91b365a5fdcbec8a1f693048faa03 /OpenSim/Client/Sirikata/Protocol/Test.pbj.cs
parentChange the signature of the forms requester data in preparation to getting (diff)
parentMerge branch 'master' of melanie@opensimulator.org:/var/git/opensim (diff)
downloadopensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.zip
opensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.tar.gz
opensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.tar.bz2
opensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.tar.xz
Merge branch 'master' into presence-refactor
Diffstat (limited to 'OpenSim/Client/Sirikata/Protocol/Test.pbj.cs')
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Test.pbj.cs1734
1 files changed, 1734 insertions, 0 deletions
diff --git a/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs
new file mode 100644
index 0000000..c753c36
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Test.pbj.cs
@@ -0,0 +1,1734 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.PB {
4 public class ExternalMessage : PBJ.IMessage {
5 protected _PBJ_Internal.ExternalMessage super;
6 public _PBJ_Internal.ExternalMessage _PBJSuper{ get { return super;} }
7 public ExternalMessage() {
8 super=new _PBJ_Internal.ExternalMessage();
9 }
10 public ExternalMessage(_PBJ_Internal.ExternalMessage reference) {
11 super=reference;
12 }
13 public static ExternalMessage defaultInstance= new ExternalMessage (_PBJ_Internal.ExternalMessage.DefaultInstance);
14 public static ExternalMessage DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.ExternalMessage.Descriptor; } }
19 public static class Types {
20 public class SubMessage : PBJ.IMessage {
21 protected _PBJ_Internal.ExternalMessage.Types.SubMessage super;
22 public _PBJ_Internal.ExternalMessage.Types.SubMessage _PBJSuper{ get { return super;} }
23 public SubMessage() {
24 super=new _PBJ_Internal.ExternalMessage.Types.SubMessage();
25 }
26 public SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage reference) {
27 super=reference;
28 }
29 public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance);
30 public static SubMessage DefaultInstance{
31 get {return defaultInstance;}
32 }
33 public static pbd.MessageDescriptor Descriptor {
34 get { return _PBJ_Internal.ExternalMessage.Types.SubMessage.Descriptor; } }
35 public static class Types {
36 }
37 public static bool WithinReservedFieldTagRange(int field_tag) {
38 return false;
39 }
40 public static bool WithinExtensionFieldTagRange(int field_tag) {
41 return false;
42 }
43 public const int SubuuidFieldTag=1;
44 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
45 public PBJ.UUID Subuuid{ get {
46 if (HasSubuuid) {
47 return PBJ._PBJ.CastUuid(super.Subuuid);
48 } else {
49 return PBJ._PBJ.CastUuid();
50 }
51 }
52 }
53 public const int SubvectorFieldTag=2;
54 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
55 public PBJ.Vector3d Subvector{ get {
56 int index=0;
57 if (HasSubvector) {
58 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
59 } else {
60 return PBJ._PBJ.CastVector3d();
61 }
62 }
63 }
64 public const int SubdurationFieldTag=3;
65 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
66 public PBJ.Duration Subduration{ get {
67 if (HasSubduration) {
68 return PBJ._PBJ.CastDuration(super.Subduration);
69 } else {
70 return PBJ._PBJ.CastDuration();
71 }
72 }
73 }
74 public const int SubnormalFieldTag=4;
75 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
76 public PBJ.Vector3f Subnormal{ get {
77 int index=0;
78 if (HasSubnormal) {
79 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
80 } else {
81 return PBJ._PBJ.CastNormal();
82 }
83 }
84 }
85 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
86 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
87 public static Builder CreateBuilder() { return new Builder(); }
88 public static Builder CreateBuilder(SubMessage prototype) {
89 return (Builder)new Builder().MergeFrom(prototype);
90 }
91 public static SubMessage ParseFrom(pb::ByteString data) {
92 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
93 }
94 public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
95 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
96 }
97 public static SubMessage ParseFrom(byte[] data) {
98 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
99 }
100 public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
101 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
102 }
103 public static SubMessage ParseFrom(global::System.IO.Stream data) {
104 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
105 }
106 public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
107 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
108 }
109 public static SubMessage ParseFrom(pb::CodedInputStream data) {
110 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data));
111 }
112 public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
113 return new SubMessage(_PBJ_Internal.ExternalMessage.Types.SubMessage.ParseFrom(data,er));
114 }
115 protected override bool _HasAllPBJFields{ get {
116 return true
117 ;
118 } }
119 public bool IsInitialized { get {
120 return super.IsInitialized&&_HasAllPBJFields;
121 } }
122 public class Builder : global::PBJ.IMessage.IBuilder{
123 protected override bool _HasAllPBJFields{ get {
124 return true
125 ;
126 } }
127 public bool IsInitialized { get {
128 return super.IsInitialized&&_HasAllPBJFields;
129 } }
130 protected _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder super;
131 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
132 public _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} }
133 public Builder() {super = new _PBJ_Internal.ExternalMessage.Types.SubMessage.Builder();}
134 public Builder(_PBJ_Internal.ExternalMessage.Types.SubMessage.Builder other) {
135 super=other;
136 }
137 public Builder Clone() {return new Builder(super.Clone());}
138 public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
139 public Builder Clear() {super.Clear();return this;}
140 public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());}
141 public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;}
142 public pbd::MessageDescriptor DescriptorForType {
143 get { return SubMessage.Descriptor; } }
144 public Builder ClearSubuuid() { super.ClearSubuuid();return this;}
145 public const int SubuuidFieldTag=1;
146 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
147 public PBJ.UUID Subuuid{ get {
148 if (HasSubuuid) {
149 return PBJ._PBJ.CastUuid(super.Subuuid);
150 } else {
151 return PBJ._PBJ.CastUuid();
152 }
153 }
154 set {
155 super.Subuuid=(PBJ._PBJ.Construct(value));
156 }
157 }
158 public Builder ClearSubvector() { super.ClearSubvector();return this;}
159 public const int SubvectorFieldTag=2;
160 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
161 public PBJ.Vector3d Subvector{ get {
162 int index=0;
163 if (HasSubvector) {
164 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
165 } else {
166 return PBJ._PBJ.CastVector3d();
167 }
168 }
169 set {
170 super.ClearSubvector();
171 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
172 super.AddSubvector(_PBJtempArray[0]);
173 super.AddSubvector(_PBJtempArray[1]);
174 super.AddSubvector(_PBJtempArray[2]);
175 }
176 }
177 public Builder ClearSubduration() { super.ClearSubduration();return this;}
178 public const int SubdurationFieldTag=3;
179 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
180 public PBJ.Duration Subduration{ get {
181 if (HasSubduration) {
182 return PBJ._PBJ.CastDuration(super.Subduration);
183 } else {
184 return PBJ._PBJ.CastDuration();
185 }
186 }
187 set {
188 super.Subduration=(PBJ._PBJ.Construct(value));
189 }
190 }
191 public Builder ClearSubnormal() { super.ClearSubnormal();return this;}
192 public const int SubnormalFieldTag=4;
193 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
194 public PBJ.Vector3f Subnormal{ get {
195 int index=0;
196 if (HasSubnormal) {
197 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
198 } else {
199 return PBJ._PBJ.CastNormal();
200 }
201 }
202 set {
203 super.ClearSubnormal();
204 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
205 super.AddSubnormal(_PBJtempArray[0]);
206 super.AddSubnormal(_PBJtempArray[1]);
207 }
208 }
209 }
210 }
211 }
212 public static bool WithinReservedFieldTagRange(int field_tag) {
213 return false;
214 }
215 public static bool WithinExtensionFieldTagRange(int field_tag) {
216 return false;
217 }
218 public const int IsTrueFieldTag=40;
219 public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} }
220 public bool IsTrue{ get {
221 if (HasIsTrue) {
222 return PBJ._PBJ.CastBool(super.IsTrue);
223 } else {
224 return true;
225 }
226 }
227 }
228 public const int V2FFieldTag=2;
229 public bool HasV2F{ get {return super.V2FCount>=2;} }
230 public PBJ.Vector2f V2F{ get {
231 int index=0;
232 if (HasV2F) {
233 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
234 } else {
235 return PBJ._PBJ.CastVector2f();
236 }
237 }
238 }
239 public const int SubMesFieldTag=30;
240 public bool HasSubMes{ get {return super.HasSubMes;} }
241 public Types.SubMessage SubMes{ get {
242 if (HasSubMes) {
243 return new Types.SubMessage(super.SubMes);
244 } else {
245 return new Types.SubMessage();
246 }
247 }
248 }
249 public const int SubmessersFieldTag=31;
250 public int SubmessersCount { get { return super.SubmessersCount;} }
251 public bool HasSubmessers(int index) {return true;}
252 public Types.SubMessage Submessers(int index) {
253 return new Types.SubMessage(super.GetSubmessers(index));
254 }
255 public const int ShaFieldTag=32;
256 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
257 public PBJ.SHA256 Sha{ get {
258 if (HasSha) {
259 return PBJ._PBJ.CastSha256(super.Sha);
260 } else {
261 return PBJ._PBJ.CastSha256();
262 }
263 }
264 }
265 public const int ShasFieldTag=33;
266 public int ShasCount { get { return super.ShasCount;} }
267 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
268 public PBJ.SHA256 Shas(int index) {
269 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
270 }
271 public const int V3FFieldTag=4;
272 public bool HasV3F{ get {return super.V3FCount>=3;} }
273 public PBJ.Vector3f V3F{ get {
274 int index=0;
275 if (HasV3F) {
276 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
277 } else {
278 return PBJ._PBJ.CastVector3f();
279 }
280 }
281 }
282 public const int V3FfFieldTag=5;
283 public int V3FfCount { get { return super.V3FfCount/3;} }
284 public bool HasV3Ff(int index) { return true; }
285 public PBJ.Vector3f GetV3Ff(int index) {
286 if (HasV3Ff(index)) {
287 return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2));
288 } else {
289 return PBJ._PBJ.CastVector3f();
290 }
291 }
292 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
293 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
294 public static Builder CreateBuilder() { return new Builder(); }
295 public static Builder CreateBuilder(ExternalMessage prototype) {
296 return (Builder)new Builder().MergeFrom(prototype);
297 }
298 public static ExternalMessage ParseFrom(pb::ByteString data) {
299 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
300 }
301 public static ExternalMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
302 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
303 }
304 public static ExternalMessage ParseFrom(byte[] data) {
305 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
306 }
307 public static ExternalMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
308 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
309 }
310 public static ExternalMessage ParseFrom(global::System.IO.Stream data) {
311 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
312 }
313 public static ExternalMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
314 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
315 }
316 public static ExternalMessage ParseFrom(pb::CodedInputStream data) {
317 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data));
318 }
319 public static ExternalMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
320 return new ExternalMessage(_PBJ_Internal.ExternalMessage.ParseFrom(data,er));
321 }
322 protected override bool _HasAllPBJFields{ get {
323 return true
324 &&HasV3F
325 ;
326 } }
327 public bool IsInitialized { get {
328 return super.IsInitialized&&_HasAllPBJFields;
329 } }
330 public class Builder : global::PBJ.IMessage.IBuilder{
331 protected override bool _HasAllPBJFields{ get {
332 return true
333 &&HasV3F
334 ;
335 } }
336 public bool IsInitialized { get {
337 return super.IsInitialized&&_HasAllPBJFields;
338 } }
339 protected _PBJ_Internal.ExternalMessage.Builder super;
340 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
341 public _PBJ_Internal.ExternalMessage.Builder _PBJSuper{ get { return super;} }
342 public Builder() {super = new _PBJ_Internal.ExternalMessage.Builder();}
343 public Builder(_PBJ_Internal.ExternalMessage.Builder other) {
344 super=other;
345 }
346 public Builder Clone() {return new Builder(super.Clone());}
347 public Builder MergeFrom(ExternalMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
348 public Builder Clear() {super.Clear();return this;}
349 public ExternalMessage BuildPartial() {return new ExternalMessage(super.BuildPartial());}
350 public ExternalMessage Build() {if (_HasAllPBJFields) return new ExternalMessage(super.Build());return null;}
351 public pbd::MessageDescriptor DescriptorForType {
352 get { return ExternalMessage.Descriptor; } }
353 public Builder ClearIsTrue() { super.ClearIsTrue();return this;}
354 public const int IsTrueFieldTag=40;
355 public bool HasIsTrue{ get {return super.HasIsTrue&&PBJ._PBJ.ValidateBool(super.IsTrue);} }
356 public bool IsTrue{ get {
357 if (HasIsTrue) {
358 return PBJ._PBJ.CastBool(super.IsTrue);
359 } else {
360 return true;
361 }
362 }
363 set {
364 super.IsTrue=(PBJ._PBJ.Construct(value));
365 }
366 }
367 public Builder ClearV2F() { super.ClearV2F();return this;}
368 public const int V2FFieldTag=2;
369 public bool HasV2F{ get {return super.V2FCount>=2;} }
370 public PBJ.Vector2f V2F{ get {
371 int index=0;
372 if (HasV2F) {
373 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
374 } else {
375 return PBJ._PBJ.CastVector2f();
376 }
377 }
378 set {
379 super.ClearV2F();
380 float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value);
381 super.AddV2F(_PBJtempArray[0]);
382 super.AddV2F(_PBJtempArray[1]);
383 }
384 }
385 public Builder ClearSubMes() { super.ClearSubMes();return this;}
386 public const int SubMesFieldTag=30;
387 public bool HasSubMes{ get {return super.HasSubMes;} }
388 public Types.SubMessage SubMes{ get {
389 if (HasSubMes) {
390 return new Types.SubMessage(super.SubMes);
391 } else {
392 return new Types.SubMessage();
393 }
394 }
395 set {
396 super.SubMes=value._PBJSuper;
397 }
398 }
399 public Builder ClearSubmessers() { super.ClearSubmessers();return this;}
400 public Builder SetSubmessers(int index,Types.SubMessage value) {
401 super.SetSubmessers(index,value._PBJSuper);
402 return this;
403 }
404 public const int SubmessersFieldTag=31;
405 public int SubmessersCount { get { return super.SubmessersCount;} }
406 public bool HasSubmessers(int index) {return true;}
407 public Types.SubMessage Submessers(int index) {
408 return new Types.SubMessage(super.GetSubmessers(index));
409 }
410 public Builder AddSubmessers(Types.SubMessage value ) {
411 super.AddSubmessers(value._PBJSuper);
412 return this;
413 }
414 public Builder ClearSha() { super.ClearSha();return this;}
415 public const int ShaFieldTag=32;
416 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
417 public PBJ.SHA256 Sha{ get {
418 if (HasSha) {
419 return PBJ._PBJ.CastSha256(super.Sha);
420 } else {
421 return PBJ._PBJ.CastSha256();
422 }
423 }
424 set {
425 super.Sha=(PBJ._PBJ.Construct(value));
426 }
427 }
428 public Builder ClearShas() { super.ClearShas();return this;}
429 public Builder SetShas(int index, PBJ.SHA256 value) {
430 super.SetShas(index,PBJ._PBJ.Construct(value));
431 return this;
432 }
433 public const int ShasFieldTag=33;
434 public int ShasCount { get { return super.ShasCount;} }
435 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
436 public PBJ.SHA256 Shas(int index) {
437 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
438 }
439 public Builder AddShas(PBJ.SHA256 value) {
440 super.AddShas(PBJ._PBJ.Construct(value));
441 return this;
442 }
443 public Builder ClearV3F() { super.ClearV3F();return this;}
444 public const int V3FFieldTag=4;
445 public bool HasV3F{ get {return super.V3FCount>=3;} }
446 public PBJ.Vector3f V3F{ get {
447 int index=0;
448 if (HasV3F) {
449 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
450 } else {
451 return PBJ._PBJ.CastVector3f();
452 }
453 }
454 set {
455 super.ClearV3F();
456 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
457 super.AddV3F(_PBJtempArray[0]);
458 super.AddV3F(_PBJtempArray[1]);
459 super.AddV3F(_PBJtempArray[2]);
460 }
461 }
462 public Builder ClearV3Ff() { super.ClearV3Ff();return this;}
463 public const int V3FfFieldTag=5;
464 public int V3FfCount { get { return super.V3FfCount/3;} }
465 public bool HasV3Ff(int index) { return true; }
466 public PBJ.Vector3f GetV3Ff(int index) {
467 if (HasV3Ff(index)) {
468 return PBJ._PBJ.CastVector3f(super.GetV3Ff(index*3+0),super.GetV3Ff(index*3+1),super.GetV3Ff(index*3+2));
469 } else {
470 return PBJ._PBJ.CastVector3f();
471 }
472 }
473 public Builder AddV3Ff(PBJ.Vector3f value) {
474 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
475 super.AddV3Ff(_PBJtempArray[0]);
476 super.AddV3Ff(_PBJtempArray[1]);
477 super.AddV3Ff(_PBJtempArray[2]);
478 return this;
479 }
480 public Builder SetV3Ff(int index,PBJ.Vector3f value) {
481 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
482 super.SetV3Ff(index*3+0,_PBJtempArray[0]);
483 super.SetV3Ff(index*3+1,_PBJtempArray[1]);
484 super.SetV3Ff(index*3+2,_PBJtempArray[2]);
485 return this;
486 }
487 }
488 }
489}
490namespace Sirikata.PB {
491 public class TestMessage : PBJ.IMessage {
492 protected _PBJ_Internal.TestMessage super;
493 public _PBJ_Internal.TestMessage _PBJSuper{ get { return super;} }
494 public TestMessage() {
495 super=new _PBJ_Internal.TestMessage();
496 }
497 public TestMessage(_PBJ_Internal.TestMessage reference) {
498 super=reference;
499 }
500 public static TestMessage defaultInstance= new TestMessage (_PBJ_Internal.TestMessage.DefaultInstance);
501 public static TestMessage DefaultInstance{
502 get {return defaultInstance;}
503 }
504 public static pbd.MessageDescriptor Descriptor {
505 get { return _PBJ_Internal.TestMessage.Descriptor; } }
506 public static class Types {
507 public enum Flagsf32 {
508 UNIVERSA=_PBJ_Internal.TestMessage.Types.Flagsf32.UNIVERSA,
509 WE=_PBJ_Internal.TestMessage.Types.Flagsf32.WE,
510 IMAGE=_PBJ_Internal.TestMessage.Types.Flagsf32.IMAGE,
511 LOCA=_PBJ_Internal.TestMessage.Types.Flagsf32.LOCA
512 };
513 public enum Flagsf64 {
514 UNIVERSAL=_PBJ_Internal.TestMessage.Types.Flagsf64.UNIVERSAL,
515 WEB=_PBJ_Internal.TestMessage.Types.Flagsf64.WEB,
516 IMAGES=_PBJ_Internal.TestMessage.Types.Flagsf64.IMAGES,
517 LOCAL=_PBJ_Internal.TestMessage.Types.Flagsf64.LOCAL
518 };
519 public enum Enum32 {
520 UNIVERSAL1=_PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1,
521 WEB1=_PBJ_Internal.TestMessage.Types.Enum32.WEB1,
522 IMAGES1=_PBJ_Internal.TestMessage.Types.Enum32.IMAGES1,
523 LOCAL1=_PBJ_Internal.TestMessage.Types.Enum32.LOCAL1
524 };
525 public class SubMessage : PBJ.IMessage {
526 protected _PBJ_Internal.TestMessage.Types.SubMessage super;
527 public _PBJ_Internal.TestMessage.Types.SubMessage _PBJSuper{ get { return super;} }
528 public SubMessage() {
529 super=new _PBJ_Internal.TestMessage.Types.SubMessage();
530 }
531 public SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage reference) {
532 super=reference;
533 }
534 public static SubMessage defaultInstance= new SubMessage (_PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance);
535 public static SubMessage DefaultInstance{
536 get {return defaultInstance;}
537 }
538 public static pbd.MessageDescriptor Descriptor {
539 get { return _PBJ_Internal.TestMessage.Types.SubMessage.Descriptor; } }
540 public static class Types {
541 }
542 public static bool WithinReservedFieldTagRange(int field_tag) {
543 return false;
544 }
545 public static bool WithinExtensionFieldTagRange(int field_tag) {
546 return false;
547 }
548 public const int SubuuidFieldTag=1;
549 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
550 public PBJ.UUID Subuuid{ get {
551 if (HasSubuuid) {
552 return PBJ._PBJ.CastUuid(super.Subuuid);
553 } else {
554 return PBJ._PBJ.CastUuid();
555 }
556 }
557 }
558 public const int SubvectorFieldTag=2;
559 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
560 public PBJ.Vector3d Subvector{ get {
561 int index=0;
562 if (HasSubvector) {
563 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
564 } else {
565 return PBJ._PBJ.CastVector3d();
566 }
567 }
568 }
569 public const int SubdurationFieldTag=3;
570 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
571 public PBJ.Duration Subduration{ get {
572 if (HasSubduration) {
573 return PBJ._PBJ.CastDuration(super.Subduration);
574 } else {
575 return PBJ._PBJ.CastDuration();
576 }
577 }
578 }
579 public const int SubnormalFieldTag=4;
580 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
581 public PBJ.Vector3f Subnormal{ get {
582 int index=0;
583 if (HasSubnormal) {
584 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
585 } else {
586 return PBJ._PBJ.CastNormal();
587 }
588 }
589 }
590 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
591 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
592 public static Builder CreateBuilder() { return new Builder(); }
593 public static Builder CreateBuilder(SubMessage prototype) {
594 return (Builder)new Builder().MergeFrom(prototype);
595 }
596 public static SubMessage ParseFrom(pb::ByteString data) {
597 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
598 }
599 public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
600 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
601 }
602 public static SubMessage ParseFrom(byte[] data) {
603 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
604 }
605 public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
606 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
607 }
608 public static SubMessage ParseFrom(global::System.IO.Stream data) {
609 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
610 }
611 public static SubMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
612 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
613 }
614 public static SubMessage ParseFrom(pb::CodedInputStream data) {
615 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data));
616 }
617 public static SubMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
618 return new SubMessage(_PBJ_Internal.TestMessage.Types.SubMessage.ParseFrom(data,er));
619 }
620 protected override bool _HasAllPBJFields{ get {
621 return true
622 ;
623 } }
624 public bool IsInitialized { get {
625 return super.IsInitialized&&_HasAllPBJFields;
626 } }
627 public class Builder : global::PBJ.IMessage.IBuilder{
628 protected override bool _HasAllPBJFields{ get {
629 return true
630 ;
631 } }
632 public bool IsInitialized { get {
633 return super.IsInitialized&&_HasAllPBJFields;
634 } }
635 protected _PBJ_Internal.TestMessage.Types.SubMessage.Builder super;
636 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
637 public _PBJ_Internal.TestMessage.Types.SubMessage.Builder _PBJSuper{ get { return super;} }
638 public Builder() {super = new _PBJ_Internal.TestMessage.Types.SubMessage.Builder();}
639 public Builder(_PBJ_Internal.TestMessage.Types.SubMessage.Builder other) {
640 super=other;
641 }
642 public Builder Clone() {return new Builder(super.Clone());}
643 public Builder MergeFrom(SubMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
644 public Builder Clear() {super.Clear();return this;}
645 public SubMessage BuildPartial() {return new SubMessage(super.BuildPartial());}
646 public SubMessage Build() {if (_HasAllPBJFields) return new SubMessage(super.Build());return null;}
647 public pbd::MessageDescriptor DescriptorForType {
648 get { return SubMessage.Descriptor; } }
649 public Builder ClearSubuuid() { super.ClearSubuuid();return this;}
650 public const int SubuuidFieldTag=1;
651 public bool HasSubuuid{ get {return super.HasSubuuid&&PBJ._PBJ.ValidateUuid(super.Subuuid);} }
652 public PBJ.UUID Subuuid{ get {
653 if (HasSubuuid) {
654 return PBJ._PBJ.CastUuid(super.Subuuid);
655 } else {
656 return PBJ._PBJ.CastUuid();
657 }
658 }
659 set {
660 super.Subuuid=(PBJ._PBJ.Construct(value));
661 }
662 }
663 public Builder ClearSubvector() { super.ClearSubvector();return this;}
664 public const int SubvectorFieldTag=2;
665 public bool HasSubvector{ get {return super.SubvectorCount>=3;} }
666 public PBJ.Vector3d Subvector{ get {
667 int index=0;
668 if (HasSubvector) {
669 return PBJ._PBJ.CastVector3d(super.GetSubvector(index*3+0),super.GetSubvector(index*3+1),super.GetSubvector(index*3+2));
670 } else {
671 return PBJ._PBJ.CastVector3d();
672 }
673 }
674 set {
675 super.ClearSubvector();
676 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
677 super.AddSubvector(_PBJtempArray[0]);
678 super.AddSubvector(_PBJtempArray[1]);
679 super.AddSubvector(_PBJtempArray[2]);
680 }
681 }
682 public Builder ClearSubduration() { super.ClearSubduration();return this;}
683 public const int SubdurationFieldTag=3;
684 public bool HasSubduration{ get {return super.HasSubduration&&PBJ._PBJ.ValidateDuration(super.Subduration);} }
685 public PBJ.Duration Subduration{ get {
686 if (HasSubduration) {
687 return PBJ._PBJ.CastDuration(super.Subduration);
688 } else {
689 return PBJ._PBJ.CastDuration();
690 }
691 }
692 set {
693 super.Subduration=(PBJ._PBJ.Construct(value));
694 }
695 }
696 public Builder ClearSubnormal() { super.ClearSubnormal();return this;}
697 public const int SubnormalFieldTag=4;
698 public bool HasSubnormal{ get {return super.SubnormalCount>=2;} }
699 public PBJ.Vector3f Subnormal{ get {
700 int index=0;
701 if (HasSubnormal) {
702 return PBJ._PBJ.CastNormal(super.GetSubnormal(index*2+0),super.GetSubnormal(index*2+1));
703 } else {
704 return PBJ._PBJ.CastNormal();
705 }
706 }
707 set {
708 super.ClearSubnormal();
709 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
710 super.AddSubnormal(_PBJtempArray[0]);
711 super.AddSubnormal(_PBJtempArray[1]);
712 }
713 }
714 }
715 }
716 }
717 public static bool WithinReservedFieldTagRange(int field_tag) {
718 return false;
719 }
720 public static bool WithinExtensionFieldTagRange(int field_tag) {
721 return false||(field_tag>=100&&field_tag<=199);
722 }
723 public const int XxdFieldTag=20;
724 public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} }
725 public double Xxd{ get {
726 if (HasXxd) {
727 return PBJ._PBJ.CastDouble(super.Xxd);
728 } else {
729 return 10.3;
730 }
731 }
732 }
733 public const int XxfFieldTag=21;
734 public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} }
735 public float Xxf{ get {
736 if (HasXxf) {
737 return PBJ._PBJ.CastFloat(super.Xxf);
738 } else {
739 return PBJ._PBJ.CastFloat();
740 }
741 }
742 }
743 public const int Xxu32FieldTag=22;
744 public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} }
745 public uint Xxu32{ get {
746 if (HasXxu32) {
747 return PBJ._PBJ.CastUint32(super.Xxu32);
748 } else {
749 return PBJ._PBJ.CastUint32();
750 }
751 }
752 }
753 public const int XxsFieldTag=23;
754 public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} }
755 public string Xxs{ get {
756 if (HasXxs) {
757 return PBJ._PBJ.CastString(super.Xxs);
758 } else {
759 return PBJ._PBJ.CastString();
760 }
761 }
762 }
763 public const int XxbFieldTag=24;
764 public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} }
765 public pb::ByteString Xxb{ get {
766 if (HasXxb) {
767 return PBJ._PBJ.CastBytes(super.Xxb);
768 } else {
769 return PBJ._PBJ.CastBytes();
770 }
771 }
772 }
773 public const int XxssFieldTag=25;
774 public int XxssCount { get { return super.XxssCount;} }
775 public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));}
776 public string Xxss(int index) {
777 return (string)PBJ._PBJ.CastString(super.GetXxss(index));
778 }
779 public const int XxbbFieldTag=26;
780 public int XxbbCount { get { return super.XxbbCount;} }
781 public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));}
782 public pb::ByteString Xxbb(int index) {
783 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index));
784 }
785 public const int XxffFieldTag=27;
786 public int XxffCount { get { return super.XxffCount;} }
787 public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));}
788 public float Xxff(int index) {
789 return (float)PBJ._PBJ.CastFloat(super.GetXxff(index));
790 }
791 public const int XxnnFieldTag=29;
792 public int XxnnCount { get { return super.XxnnCount/2;} }
793 public bool HasXxnn(int index) { return true; }
794 public PBJ.Vector3f GetXxnn(int index) {
795 if (HasXxnn(index)) {
796 return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1));
797 } else {
798 return PBJ._PBJ.CastNormal();
799 }
800 }
801 public const int XxfrFieldTag=28;
802 public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} }
803 public float Xxfr{ get {
804 if (HasXxfr) {
805 return PBJ._PBJ.CastFloat(super.Xxfr);
806 } else {
807 return PBJ._PBJ.CastFloat();
808 }
809 }
810 }
811 public const int NFieldTag=1;
812 public bool HasN{ get {return super.NCount>=2;} }
813 public PBJ.Vector3f N{ get {
814 int index=0;
815 if (HasN) {
816 return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1));
817 } else {
818 return PBJ._PBJ.CastNormal();
819 }
820 }
821 }
822 public const int V2FFieldTag=2;
823 public bool HasV2F{ get {return super.V2FCount>=2;} }
824 public PBJ.Vector2f V2F{ get {
825 int index=0;
826 if (HasV2F) {
827 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
828 } else {
829 return PBJ._PBJ.CastVector2f();
830 }
831 }
832 }
833 public const int V2DFieldTag=3;
834 public bool HasV2D{ get {return super.V2DCount>=2;} }
835 public PBJ.Vector2d V2D{ get {
836 int index=0;
837 if (HasV2D) {
838 return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1));
839 } else {
840 return PBJ._PBJ.CastVector2d();
841 }
842 }
843 }
844 public const int V3FFieldTag=4;
845 public bool HasV3F{ get {return super.V3FCount>=3;} }
846 public PBJ.Vector3f V3F{ get {
847 int index=0;
848 if (HasV3F) {
849 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
850 } else {
851 return PBJ._PBJ.CastVector3f();
852 }
853 }
854 }
855 public const int V3DFieldTag=5;
856 public bool HasV3D{ get {return super.V3DCount>=3;} }
857 public PBJ.Vector3d V3D{ get {
858 int index=0;
859 if (HasV3D) {
860 return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2));
861 } else {
862 return PBJ._PBJ.CastVector3d();
863 }
864 }
865 }
866 public const int V4FFieldTag=6;
867 public bool HasV4F{ get {return super.V4FCount>=4;} }
868 public PBJ.Vector4f V4F{ get {
869 int index=0;
870 if (HasV4F) {
871 return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3));
872 } else {
873 return PBJ._PBJ.CastVector4f();
874 }
875 }
876 }
877 public const int V4DFieldTag=7;
878 public bool HasV4D{ get {return super.V4DCount>=4;} }
879 public PBJ.Vector4d V4D{ get {
880 int index=0;
881 if (HasV4D) {
882 return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3));
883 } else {
884 return PBJ._PBJ.CastVector4d();
885 }
886 }
887 }
888 public const int QFieldTag=8;
889 public bool HasQ{ get {return super.QCount>=3;} }
890 public PBJ.Quaternion Q{ get {
891 int index=0;
892 if (HasQ) {
893 return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2));
894 } else {
895 return PBJ._PBJ.CastQuaternion();
896 }
897 }
898 }
899 public const int UFieldTag=9;
900 public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} }
901 public PBJ.UUID U{ get {
902 if (HasU) {
903 return PBJ._PBJ.CastUuid(super.U);
904 } else {
905 return PBJ._PBJ.CastUuid();
906 }
907 }
908 }
909 public const int AFieldTag=10;
910 public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} }
911 public float A{ get {
912 if (HasA) {
913 return PBJ._PBJ.CastAngle(super.A);
914 } else {
915 return PBJ._PBJ.CastAngle();
916 }
917 }
918 }
919 public const int TFieldTag=11;
920 public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} }
921 public PBJ.Time T{ get {
922 if (HasT) {
923 return PBJ._PBJ.CastTime(super.T);
924 } else {
925 return PBJ._PBJ.CastTime();
926 }
927 }
928 }
929 public const int DFieldTag=12;
930 public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} }
931 public PBJ.Duration D{ get {
932 if (HasD) {
933 return PBJ._PBJ.CastDuration(super.D);
934 } else {
935 return PBJ._PBJ.CastDuration();
936 }
937 }
938 }
939 public const int F32FieldTag=13;
940 public bool HasF32 { get {
941 if (!super.HasF32) return false;
942 return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
943 } }
944 public uint F32{ get {
945 if (HasF32) {
946 return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
947 } else {
948 return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
949 }
950 }
951 }
952 public const int F64FieldTag=14;
953 public bool HasF64 { get {
954 if (!super.HasF64) return false;
955 return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
956 } }
957 public ulong F64{ get {
958 if (HasF64) {
959 return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
960 } else {
961 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
962 }
963 }
964 }
965 public const int BsfFieldTag=15;
966 public bool HasBsf{ get {return super.BsfCount>=4;} }
967 public PBJ.BoundingSphere3f Bsf{ get {
968 int index=0;
969 if (HasBsf) {
970 return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3));
971 } else {
972 return PBJ._PBJ.CastBoundingsphere3f();
973 }
974 }
975 }
976 public const int BsdFieldTag=16;
977 public bool HasBsd{ get {return super.BsdCount>=4;} }
978 public PBJ.BoundingSphere3d Bsd{ get {
979 int index=0;
980 if (HasBsd) {
981 return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3));
982 } else {
983 return PBJ._PBJ.CastBoundingsphere3d();
984 }
985 }
986 }
987 public const int BbfFieldTag=17;
988 public bool HasBbf{ get {return super.BbfCount>=6;} }
989 public PBJ.BoundingBox3f3f Bbf{ get {
990 int index=0;
991 if (HasBbf) {
992 return PBJ._PBJ.CastBoundingbox3f3f(super.GetBbf(index*6+0),super.GetBbf(index*6+1),super.GetBbf(index*6+2),super.GetBbf(index*6+3),super.GetBbf(index*6+4),super.GetBbf(index*6+5));
993 } else {
994 return PBJ._PBJ.CastBoundingbox3f3f();
995 }
996 }
997 }
998 public const int BbdFieldTag=18;
999 public bool HasBbd{ get {return super.BbdCount>=6;} }
1000 public PBJ.BoundingBox3d3f Bbd{ get {
1001 int index=0;
1002 if (HasBbd) {
1003 return PBJ._PBJ.CastBoundingbox3d3f(super.GetBbd(index*6+0),super.GetBbd(index*6+1),super.GetBbd(index*6+2),super.GetBbd(index*6+3),super.GetBbd(index*6+4),super.GetBbd(index*6+5));
1004 } else {
1005 return PBJ._PBJ.CastBoundingbox3d3f();
1006 }
1007 }
1008 }
1009 public const int E32FieldTag=19;
1010 public bool HasE32{ get {return super.HasE32;} }
1011 public Types.Enum32 E32{ get {
1012 if (HasE32) {
1013 return (Types.Enum32)super.E32;
1014 } else {
1015 return new Types.Enum32();
1016 }
1017 }
1018 }
1019 public const int SubmesFieldTag=30;
1020 public bool HasSubmes{ get {return super.HasSubmes;} }
1021 public Types.SubMessage Submes{ get {
1022 if (HasSubmes) {
1023 return new Types.SubMessage(super.Submes);
1024 } else {
1025 return new Types.SubMessage();
1026 }
1027 }
1028 }
1029 public const int SubmessersFieldTag=31;
1030 public int SubmessersCount { get { return super.SubmessersCount;} }
1031 public bool HasSubmessers(int index) {return true;}
1032 public Types.SubMessage Submessers(int index) {
1033 return new Types.SubMessage(super.GetSubmessers(index));
1034 }
1035 public const int ShaFieldTag=32;
1036 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
1037 public PBJ.SHA256 Sha{ get {
1038 if (HasSha) {
1039 return PBJ._PBJ.CastSha256(super.Sha);
1040 } else {
1041 return PBJ._PBJ.CastSha256();
1042 }
1043 }
1044 }
1045 public const int ShasFieldTag=33;
1046 public int ShasCount { get { return super.ShasCount;} }
1047 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
1048 public PBJ.SHA256 Shas(int index) {
1049 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
1050 }
1051 public const int ExtmesFieldTag=34;
1052 public bool HasExtmes{ get {return super.HasExtmes;} }
1053 public ExternalMessage Extmes{ get {
1054 if (HasExtmes) {
1055 return new ExternalMessage(super.Extmes);
1056 } else {
1057 return new ExternalMessage();
1058 }
1059 }
1060 }
1061 public const int ExtmessersFieldTag=35;
1062 public int ExtmessersCount { get { return super.ExtmessersCount;} }
1063 public bool HasExtmessers(int index) {return true;}
1064 public ExternalMessage Extmessers(int index) {
1065 return new ExternalMessage(super.GetExtmessers(index));
1066 }
1067 public const int ExtmesserFieldTag=36;
1068 public bool HasExtmesser{ get {return super.HasExtmesser;} }
1069 public ExternalMessage Extmesser{ get {
1070 if (HasExtmesser) {
1071 return new ExternalMessage(super.Extmesser);
1072 } else {
1073 return new ExternalMessage();
1074 }
1075 }
1076 }
1077 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1078 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1079 public static Builder CreateBuilder() { return new Builder(); }
1080 public static Builder CreateBuilder(TestMessage prototype) {
1081 return (Builder)new Builder().MergeFrom(prototype);
1082 }
1083 public static TestMessage ParseFrom(pb::ByteString data) {
1084 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1085 }
1086 public static TestMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1087 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1088 }
1089 public static TestMessage ParseFrom(byte[] data) {
1090 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1091 }
1092 public static TestMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1093 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1094 }
1095 public static TestMessage ParseFrom(global::System.IO.Stream data) {
1096 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1097 }
1098 public static TestMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1099 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1100 }
1101 public static TestMessage ParseFrom(pb::CodedInputStream data) {
1102 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data));
1103 }
1104 public static TestMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1105 return new TestMessage(_PBJ_Internal.TestMessage.ParseFrom(data,er));
1106 }
1107 protected override bool _HasAllPBJFields{ get {
1108 return true
1109 &&HasV3F
1110 ;
1111 } }
1112 public bool IsInitialized { get {
1113 return super.IsInitialized&&_HasAllPBJFields;
1114 } }
1115 public class Builder : global::PBJ.IMessage.IBuilder{
1116 protected override bool _HasAllPBJFields{ get {
1117 return true
1118 &&HasV3F
1119 ;
1120 } }
1121 public bool IsInitialized { get {
1122 return super.IsInitialized&&_HasAllPBJFields;
1123 } }
1124 protected _PBJ_Internal.TestMessage.Builder super;
1125 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1126 public _PBJ_Internal.TestMessage.Builder _PBJSuper{ get { return super;} }
1127 public Builder() {super = new _PBJ_Internal.TestMessage.Builder();}
1128 public Builder(_PBJ_Internal.TestMessage.Builder other) {
1129 super=other;
1130 }
1131 public Builder Clone() {return new Builder(super.Clone());}
1132 public Builder MergeFrom(TestMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1133 public Builder Clear() {super.Clear();return this;}
1134 public TestMessage BuildPartial() {return new TestMessage(super.BuildPartial());}
1135 public TestMessage Build() {if (_HasAllPBJFields) return new TestMessage(super.Build());return null;}
1136 public pbd::MessageDescriptor DescriptorForType {
1137 get { return TestMessage.Descriptor; } }
1138 public Builder ClearXxd() { super.ClearXxd();return this;}
1139 public const int XxdFieldTag=20;
1140 public bool HasXxd{ get {return super.HasXxd&&PBJ._PBJ.ValidateDouble(super.Xxd);} }
1141 public double Xxd{ get {
1142 if (HasXxd) {
1143 return PBJ._PBJ.CastDouble(super.Xxd);
1144 } else {
1145 return 10.3;
1146 }
1147 }
1148 set {
1149 super.Xxd=(PBJ._PBJ.Construct(value));
1150 }
1151 }
1152 public Builder ClearXxf() { super.ClearXxf();return this;}
1153 public const int XxfFieldTag=21;
1154 public bool HasXxf{ get {return super.HasXxf&&PBJ._PBJ.ValidateFloat(super.Xxf);} }
1155 public float Xxf{ get {
1156 if (HasXxf) {
1157 return PBJ._PBJ.CastFloat(super.Xxf);
1158 } else {
1159 return PBJ._PBJ.CastFloat();
1160 }
1161 }
1162 set {
1163 super.Xxf=(PBJ._PBJ.Construct(value));
1164 }
1165 }
1166 public Builder ClearXxu32() { super.ClearXxu32();return this;}
1167 public const int Xxu32FieldTag=22;
1168 public bool HasXxu32{ get {return super.HasXxu32&&PBJ._PBJ.ValidateUint32(super.Xxu32);} }
1169 public uint Xxu32{ get {
1170 if (HasXxu32) {
1171 return PBJ._PBJ.CastUint32(super.Xxu32);
1172 } else {
1173 return PBJ._PBJ.CastUint32();
1174 }
1175 }
1176 set {
1177 super.Xxu32=(PBJ._PBJ.Construct(value));
1178 }
1179 }
1180 public Builder ClearXxs() { super.ClearXxs();return this;}
1181 public const int XxsFieldTag=23;
1182 public bool HasXxs{ get {return super.HasXxs&&PBJ._PBJ.ValidateString(super.Xxs);} }
1183 public string Xxs{ get {
1184 if (HasXxs) {
1185 return PBJ._PBJ.CastString(super.Xxs);
1186 } else {
1187 return PBJ._PBJ.CastString();
1188 }
1189 }
1190 set {
1191 super.Xxs=(PBJ._PBJ.Construct(value));
1192 }
1193 }
1194 public Builder ClearXxb() { super.ClearXxb();return this;}
1195 public const int XxbFieldTag=24;
1196 public bool HasXxb{ get {return super.HasXxb&&PBJ._PBJ.ValidateBytes(super.Xxb);} }
1197 public pb::ByteString Xxb{ get {
1198 if (HasXxb) {
1199 return PBJ._PBJ.CastBytes(super.Xxb);
1200 } else {
1201 return PBJ._PBJ.CastBytes();
1202 }
1203 }
1204 set {
1205 super.Xxb=(PBJ._PBJ.Construct(value));
1206 }
1207 }
1208 public Builder ClearXxss() { super.ClearXxss();return this;}
1209 public Builder SetXxss(int index, string value) {
1210 super.SetXxss(index,PBJ._PBJ.Construct(value));
1211 return this;
1212 }
1213 public const int XxssFieldTag=25;
1214 public int XxssCount { get { return super.XxssCount;} }
1215 public bool HasXxss(int index) {return PBJ._PBJ.ValidateString(super.GetXxss(index));}
1216 public string Xxss(int index) {
1217 return (string)PBJ._PBJ.CastString(super.GetXxss(index));
1218 }
1219 public Builder AddXxss(string value) {
1220 super.AddXxss(PBJ._PBJ.Construct(value));
1221 return this;
1222 }
1223 public Builder ClearXxbb() { super.ClearXxbb();return this;}
1224 public Builder SetXxbb(int index, pb::ByteString value) {
1225 super.SetXxbb(index,PBJ._PBJ.Construct(value));
1226 return this;
1227 }
1228 public const int XxbbFieldTag=26;
1229 public int XxbbCount { get { return super.XxbbCount;} }
1230 public bool HasXxbb(int index) {return PBJ._PBJ.ValidateBytes(super.GetXxbb(index));}
1231 public pb::ByteString Xxbb(int index) {
1232 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetXxbb(index));
1233 }
1234 public Builder AddXxbb(pb::ByteString value) {
1235 super.AddXxbb(PBJ._PBJ.Construct(value));
1236 return this;
1237 }
1238 public Builder ClearXxff() { super.ClearXxff();return this;}
1239 public Builder SetXxff(int index, float value) {
1240 super.SetXxff(index,PBJ._PBJ.Construct(value));
1241 return this;
1242 }
1243 public const int XxffFieldTag=27;
1244 public int XxffCount { get { return super.XxffCount;} }
1245 public bool HasXxff(int index) {return PBJ._PBJ.ValidateFloat(super.GetXxff(index));}
1246 public float Xxff(int index) {
1247 return (float)PBJ._PBJ.CastFloat(super.GetXxff(index));
1248 }
1249 public Builder AddXxff(float value) {
1250 super.AddXxff(PBJ._PBJ.Construct(value));
1251 return this;
1252 }
1253 public Builder ClearXxnn() { super.ClearXxnn();return this;}
1254 public const int XxnnFieldTag=29;
1255 public int XxnnCount { get { return super.XxnnCount/2;} }
1256 public bool HasXxnn(int index) { return true; }
1257 public PBJ.Vector3f GetXxnn(int index) {
1258 if (HasXxnn(index)) {
1259 return PBJ._PBJ.CastNormal(super.GetXxnn(index*2+0),super.GetXxnn(index*2+1));
1260 } else {
1261 return PBJ._PBJ.CastNormal();
1262 }
1263 }
1264 public Builder AddXxnn(PBJ.Vector3f value) {
1265 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1266 super.AddXxnn(_PBJtempArray[0]);
1267 super.AddXxnn(_PBJtempArray[1]);
1268 return this;
1269 }
1270 public Builder SetXxnn(int index,PBJ.Vector3f value) {
1271 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1272 super.SetXxnn(index*2+0,_PBJtempArray[0]);
1273 super.SetXxnn(index*2+1,_PBJtempArray[1]);
1274 return this;
1275 }
1276 public Builder ClearXxfr() { super.ClearXxfr();return this;}
1277 public const int XxfrFieldTag=28;
1278 public bool HasXxfr{ get {return super.HasXxfr&&PBJ._PBJ.ValidateFloat(super.Xxfr);} }
1279 public float Xxfr{ get {
1280 if (HasXxfr) {
1281 return PBJ._PBJ.CastFloat(super.Xxfr);
1282 } else {
1283 return PBJ._PBJ.CastFloat();
1284 }
1285 }
1286 set {
1287 super.Xxfr=(PBJ._PBJ.Construct(value));
1288 }
1289 }
1290 public Builder ClearN() { super.ClearN();return this;}
1291 public const int NFieldTag=1;
1292 public bool HasN{ get {return super.NCount>=2;} }
1293 public PBJ.Vector3f N{ get {
1294 int index=0;
1295 if (HasN) {
1296 return PBJ._PBJ.CastNormal(super.GetN(index*2+0),super.GetN(index*2+1));
1297 } else {
1298 return PBJ._PBJ.CastNormal();
1299 }
1300 }
1301 set {
1302 super.ClearN();
1303 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1304 super.AddN(_PBJtempArray[0]);
1305 super.AddN(_PBJtempArray[1]);
1306 }
1307 }
1308 public Builder ClearV2F() { super.ClearV2F();return this;}
1309 public const int V2FFieldTag=2;
1310 public bool HasV2F{ get {return super.V2FCount>=2;} }
1311 public PBJ.Vector2f V2F{ get {
1312 int index=0;
1313 if (HasV2F) {
1314 return PBJ._PBJ.CastVector2f(super.GetV2F(index*2+0),super.GetV2F(index*2+1));
1315 } else {
1316 return PBJ._PBJ.CastVector2f();
1317 }
1318 }
1319 set {
1320 super.ClearV2F();
1321 float[] _PBJtempArray=PBJ._PBJ.ConstructVector2f(value);
1322 super.AddV2F(_PBJtempArray[0]);
1323 super.AddV2F(_PBJtempArray[1]);
1324 }
1325 }
1326 public Builder ClearV2D() { super.ClearV2D();return this;}
1327 public const int V2DFieldTag=3;
1328 public bool HasV2D{ get {return super.V2DCount>=2;} }
1329 public PBJ.Vector2d V2D{ get {
1330 int index=0;
1331 if (HasV2D) {
1332 return PBJ._PBJ.CastVector2d(super.GetV2D(index*2+0),super.GetV2D(index*2+1));
1333 } else {
1334 return PBJ._PBJ.CastVector2d();
1335 }
1336 }
1337 set {
1338 super.ClearV2D();
1339 double[] _PBJtempArray=PBJ._PBJ.ConstructVector2d(value);
1340 super.AddV2D(_PBJtempArray[0]);
1341 super.AddV2D(_PBJtempArray[1]);
1342 }
1343 }
1344 public Builder ClearV3F() { super.ClearV3F();return this;}
1345 public const int V3FFieldTag=4;
1346 public bool HasV3F{ get {return super.V3FCount>=3;} }
1347 public PBJ.Vector3f V3F{ get {
1348 int index=0;
1349 if (HasV3F) {
1350 return PBJ._PBJ.CastVector3f(super.GetV3F(index*3+0),super.GetV3F(index*3+1),super.GetV3F(index*3+2));
1351 } else {
1352 return PBJ._PBJ.CastVector3f();
1353 }
1354 }
1355 set {
1356 super.ClearV3F();
1357 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
1358 super.AddV3F(_PBJtempArray[0]);
1359 super.AddV3F(_PBJtempArray[1]);
1360 super.AddV3F(_PBJtempArray[2]);
1361 }
1362 }
1363 public Builder ClearV3D() { super.ClearV3D();return this;}
1364 public const int V3DFieldTag=5;
1365 public bool HasV3D{ get {return super.V3DCount>=3;} }
1366 public PBJ.Vector3d V3D{ get {
1367 int index=0;
1368 if (HasV3D) {
1369 return PBJ._PBJ.CastVector3d(super.GetV3D(index*3+0),super.GetV3D(index*3+1),super.GetV3D(index*3+2));
1370 } else {
1371 return PBJ._PBJ.CastVector3d();
1372 }
1373 }
1374 set {
1375 super.ClearV3D();
1376 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
1377 super.AddV3D(_PBJtempArray[0]);
1378 super.AddV3D(_PBJtempArray[1]);
1379 super.AddV3D(_PBJtempArray[2]);
1380 }
1381 }
1382 public Builder ClearV4F() { super.ClearV4F();return this;}
1383 public const int V4FFieldTag=6;
1384 public bool HasV4F{ get {return super.V4FCount>=4;} }
1385 public PBJ.Vector4f V4F{ get {
1386 int index=0;
1387 if (HasV4F) {
1388 return PBJ._PBJ.CastVector4f(super.GetV4F(index*4+0),super.GetV4F(index*4+1),super.GetV4F(index*4+2),super.GetV4F(index*4+3));
1389 } else {
1390 return PBJ._PBJ.CastVector4f();
1391 }
1392 }
1393 set {
1394 super.ClearV4F();
1395 float[] _PBJtempArray=PBJ._PBJ.ConstructVector4f(value);
1396 super.AddV4F(_PBJtempArray[0]);
1397 super.AddV4F(_PBJtempArray[1]);
1398 super.AddV4F(_PBJtempArray[2]);
1399 super.AddV4F(_PBJtempArray[3]);
1400 }
1401 }
1402 public Builder ClearV4D() { super.ClearV4D();return this;}
1403 public const int V4DFieldTag=7;
1404 public bool HasV4D{ get {return super.V4DCount>=4;} }
1405 public PBJ.Vector4d V4D{ get {
1406 int index=0;
1407 if (HasV4D) {
1408 return PBJ._PBJ.CastVector4d(super.GetV4D(index*4+0),super.GetV4D(index*4+1),super.GetV4D(index*4+2),super.GetV4D(index*4+3));
1409 } else {
1410 return PBJ._PBJ.CastVector4d();
1411 }
1412 }
1413 set {
1414 super.ClearV4D();
1415 double[] _PBJtempArray=PBJ._PBJ.ConstructVector4d(value);
1416 super.AddV4D(_PBJtempArray[0]);
1417 super.AddV4D(_PBJtempArray[1]);
1418 super.AddV4D(_PBJtempArray[2]);
1419 super.AddV4D(_PBJtempArray[3]);
1420 }
1421 }
1422 public Builder ClearQ() { super.ClearQ();return this;}
1423 public const int QFieldTag=8;
1424 public bool HasQ{ get {return super.QCount>=3;} }
1425 public PBJ.Quaternion Q{ get {
1426 int index=0;
1427 if (HasQ) {
1428 return PBJ._PBJ.CastQuaternion(super.GetQ(index*3+0),super.GetQ(index*3+1),super.GetQ(index*3+2));
1429 } else {
1430 return PBJ._PBJ.CastQuaternion();
1431 }
1432 }
1433 set {
1434 super.ClearQ();
1435 float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value);
1436 super.AddQ(_PBJtempArray[0]);
1437 super.AddQ(_PBJtempArray[1]);
1438 super.AddQ(_PBJtempArray[2]);
1439 }
1440 }
1441 public Builder ClearU() { super.ClearU();return this;}
1442 public const int UFieldTag=9;
1443 public bool HasU{ get {return super.HasU&&PBJ._PBJ.ValidateUuid(super.U);} }
1444 public PBJ.UUID U{ get {
1445 if (HasU) {
1446 return PBJ._PBJ.CastUuid(super.U);
1447 } else {
1448 return PBJ._PBJ.CastUuid();
1449 }
1450 }
1451 set {
1452 super.U=(PBJ._PBJ.Construct(value));
1453 }
1454 }
1455 public Builder ClearA() { super.ClearA();return this;}
1456 public const int AFieldTag=10;
1457 public bool HasA{ get {return super.HasA&&PBJ._PBJ.ValidateAngle(super.A);} }
1458 public float A{ get {
1459 if (HasA) {
1460 return PBJ._PBJ.CastAngle(super.A);
1461 } else {
1462 return PBJ._PBJ.CastAngle();
1463 }
1464 }
1465 set {
1466 super.A=(PBJ._PBJ.Construct(value));
1467 }
1468 }
1469 public Builder ClearT() { super.ClearT();return this;}
1470 public const int TFieldTag=11;
1471 public bool HasT{ get {return super.HasT&&PBJ._PBJ.ValidateTime(super.T);} }
1472 public PBJ.Time T{ get {
1473 if (HasT) {
1474 return PBJ._PBJ.CastTime(super.T);
1475 } else {
1476 return PBJ._PBJ.CastTime();
1477 }
1478 }
1479 set {
1480 super.T=(PBJ._PBJ.Construct(value));
1481 }
1482 }
1483 public Builder ClearD() { super.ClearD();return this;}
1484 public const int DFieldTag=12;
1485 public bool HasD{ get {return super.HasD&&PBJ._PBJ.ValidateDuration(super.D);} }
1486 public PBJ.Duration D{ get {
1487 if (HasD) {
1488 return PBJ._PBJ.CastDuration(super.D);
1489 } else {
1490 return PBJ._PBJ.CastDuration();
1491 }
1492 }
1493 set {
1494 super.D=(PBJ._PBJ.Construct(value));
1495 }
1496 }
1497 public Builder ClearF32() { super.ClearF32();return this;}
1498 public const int F32FieldTag=13;
1499 public bool HasF32 { get {
1500 if (!super.HasF32) return false;
1501 return PBJ._PBJ.ValidateFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
1502 } }
1503 public uint F32{ get {
1504 if (HasF32) {
1505 return (uint)PBJ._PBJ.CastFlags(super.F32,(ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
1506 } else {
1507 return (uint)PBJ._PBJ.CastFlags((ulong)Types.Flagsf32.UNIVERSA|(ulong)Types.Flagsf32.WE|(ulong)Types.Flagsf32.IMAGE|(ulong)Types.Flagsf32.LOCA);
1508 }
1509 }
1510 set {
1511 super.F32=((value));
1512 }
1513 }
1514 public Builder ClearF64() { super.ClearF64();return this;}
1515 public const int F64FieldTag=14;
1516 public bool HasF64 { get {
1517 if (!super.HasF64) return false;
1518 return PBJ._PBJ.ValidateFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
1519 } }
1520 public ulong F64{ get {
1521 if (HasF64) {
1522 return (ulong)PBJ._PBJ.CastFlags(super.F64,(ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
1523 } else {
1524 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.Flagsf64.UNIVERSAL|(ulong)Types.Flagsf64.WEB|(ulong)Types.Flagsf64.IMAGES|(ulong)Types.Flagsf64.LOCAL);
1525 }
1526 }
1527 set {
1528 super.F64=((value));
1529 }
1530 }
1531 public Builder ClearBsf() { super.ClearBsf();return this;}
1532 public const int BsfFieldTag=15;
1533 public bool HasBsf{ get {return super.BsfCount>=4;} }
1534 public PBJ.BoundingSphere3f Bsf{ get {
1535 int index=0;
1536 if (HasBsf) {
1537 return PBJ._PBJ.CastBoundingsphere3f(super.GetBsf(index*4+0),super.GetBsf(index*4+1),super.GetBsf(index*4+2),super.GetBsf(index*4+3));
1538 } else {
1539 return PBJ._PBJ.CastBoundingsphere3f();
1540 }
1541 }
1542 set {
1543 super.ClearBsf();
1544 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
1545 super.AddBsf(_PBJtempArray[0]);
1546 super.AddBsf(_PBJtempArray[1]);
1547 super.AddBsf(_PBJtempArray[2]);
1548 super.AddBsf(_PBJtempArray[3]);
1549 }
1550 }
1551 public Builder ClearBsd() { super.ClearBsd();return this;}
1552 public const int BsdFieldTag=16;
1553 public bool HasBsd{ get {return super.BsdCount>=4;} }
1554 public PBJ.BoundingSphere3d Bsd{ get {
1555 int index=0;
1556 if (HasBsd) {
1557 return PBJ._PBJ.CastBoundingsphere3d(super.GetBsd(index*4+0),super.GetBsd(index*4+1),super.GetBsd(index*4+2),super.GetBsd(index*4+3));
1558 } else {
1559 return PBJ._PBJ.CastBoundingsphere3d();
1560 }
1561 }
1562 set {
1563 super.ClearBsd();
1564 double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3d(value);
1565 super.AddBsd(_PBJtempArray[0]);
1566 super.AddBsd(_PBJtempArray[1]);
1567 super.AddBsd(_PBJtempArray[2]);
1568 super.AddBsd(_PBJtempArray[3]);
1569 }
1570 }
1571 public Builder ClearBbf() { super.ClearBbf();return this;}
1572 public const int BbfFieldTag=17;
1573 public bool HasBbf{ get {return super.BbfCount>=6;} }
1574 public PBJ.BoundingBox3f3f Bbf{ get {
1575 int index=0;
1576 if (HasBbf) {
1577 return PBJ._PBJ.CastBoundingbox3f3f(super.GetBbf(index*6+0),super.GetBbf(index*6+1),super.GetBbf(index*6+2),super.GetBbf(index*6+3),super.GetBbf(index*6+4),super.GetBbf(index*6+5));
1578 } else {
1579 return PBJ._PBJ.CastBoundingbox3f3f();
1580 }
1581 }
1582 set {
1583 super.ClearBbf();
1584 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3f3f(value);
1585 super.AddBbf(_PBJtempArray[0]);
1586 super.AddBbf(_PBJtempArray[1]);
1587 super.AddBbf(_PBJtempArray[2]);
1588 super.AddBbf(_PBJtempArray[3]);
1589 super.AddBbf(_PBJtempArray[4]);
1590 super.AddBbf(_PBJtempArray[5]);
1591 }
1592 }
1593 public Builder ClearBbd() { super.ClearBbd();return this;}
1594 public const int BbdFieldTag=18;
1595 public bool HasBbd{ get {return super.BbdCount>=6;} }
1596 public PBJ.BoundingBox3d3f Bbd{ get {
1597 int index=0;
1598 if (HasBbd) {
1599 return PBJ._PBJ.CastBoundingbox3d3f(super.GetBbd(index*6+0),super.GetBbd(index*6+1),super.GetBbd(index*6+2),super.GetBbd(index*6+3),super.GetBbd(index*6+4),super.GetBbd(index*6+5));
1600 } else {
1601 return PBJ._PBJ.CastBoundingbox3d3f();
1602 }
1603 }
1604 set {
1605 super.ClearBbd();
1606 double[] _PBJtempArray=PBJ._PBJ.ConstructBoundingbox3d3f(value);
1607 super.AddBbd(_PBJtempArray[0]);
1608 super.AddBbd(_PBJtempArray[1]);
1609 super.AddBbd(_PBJtempArray[2]);
1610 super.AddBbd(_PBJtempArray[3]);
1611 super.AddBbd(_PBJtempArray[4]);
1612 super.AddBbd(_PBJtempArray[5]);
1613 }
1614 }
1615 public Builder ClearE32() { super.ClearE32();return this;}
1616 public const int E32FieldTag=19;
1617 public bool HasE32{ get {return super.HasE32;} }
1618 public Types.Enum32 E32{ get {
1619 if (HasE32) {
1620 return (Types.Enum32)super.E32;
1621 } else {
1622 return new Types.Enum32();
1623 }
1624 }
1625 set {
1626 super.E32=((_PBJ_Internal.TestMessage.Types.Enum32)value);
1627 }
1628 }
1629 public Builder ClearSubmes() { super.ClearSubmes();return this;}
1630 public const int SubmesFieldTag=30;
1631 public bool HasSubmes{ get {return super.HasSubmes;} }
1632 public Types.SubMessage Submes{ get {
1633 if (HasSubmes) {
1634 return new Types.SubMessage(super.Submes);
1635 } else {
1636 return new Types.SubMessage();
1637 }
1638 }
1639 set {
1640 super.Submes=value._PBJSuper;
1641 }
1642 }
1643 public Builder ClearSubmessers() { super.ClearSubmessers();return this;}
1644 public Builder SetSubmessers(int index,Types.SubMessage value) {
1645 super.SetSubmessers(index,value._PBJSuper);
1646 return this;
1647 }
1648 public const int SubmessersFieldTag=31;
1649 public int SubmessersCount { get { return super.SubmessersCount;} }
1650 public bool HasSubmessers(int index) {return true;}
1651 public Types.SubMessage Submessers(int index) {
1652 return new Types.SubMessage(super.GetSubmessers(index));
1653 }
1654 public Builder AddSubmessers(Types.SubMessage value ) {
1655 super.AddSubmessers(value._PBJSuper);
1656 return this;
1657 }
1658 public Builder ClearSha() { super.ClearSha();return this;}
1659 public const int ShaFieldTag=32;
1660 public bool HasSha{ get {return super.HasSha&&PBJ._PBJ.ValidateSha256(super.Sha);} }
1661 public PBJ.SHA256 Sha{ get {
1662 if (HasSha) {
1663 return PBJ._PBJ.CastSha256(super.Sha);
1664 } else {
1665 return PBJ._PBJ.CastSha256();
1666 }
1667 }
1668 set {
1669 super.Sha=(PBJ._PBJ.Construct(value));
1670 }
1671 }
1672 public Builder ClearShas() { super.ClearShas();return this;}
1673 public Builder SetShas(int index, PBJ.SHA256 value) {
1674 super.SetShas(index,PBJ._PBJ.Construct(value));
1675 return this;
1676 }
1677 public const int ShasFieldTag=33;
1678 public int ShasCount { get { return super.ShasCount;} }
1679 public bool HasShas(int index) {return PBJ._PBJ.ValidateSha256(super.GetShas(index));}
1680 public PBJ.SHA256 Shas(int index) {
1681 return (PBJ.SHA256)PBJ._PBJ.CastSha256(super.GetShas(index));
1682 }
1683 public Builder AddShas(PBJ.SHA256 value) {
1684 super.AddShas(PBJ._PBJ.Construct(value));
1685 return this;
1686 }
1687 public Builder ClearExtmes() { super.ClearExtmes();return this;}
1688 public const int ExtmesFieldTag=34;
1689 public bool HasExtmes{ get {return super.HasExtmes;} }
1690 public ExternalMessage Extmes{ get {
1691 if (HasExtmes) {
1692 return new ExternalMessage(super.Extmes);
1693 } else {
1694 return new ExternalMessage();
1695 }
1696 }
1697 set {
1698 super.Extmes=value._PBJSuper;
1699 }
1700 }
1701 public Builder ClearExtmessers() { super.ClearExtmessers();return this;}
1702 public Builder SetExtmessers(int index,ExternalMessage value) {
1703 super.SetExtmessers(index,value._PBJSuper);
1704 return this;
1705 }
1706 public const int ExtmessersFieldTag=35;
1707 public int ExtmessersCount { get { return super.ExtmessersCount;} }
1708 public bool HasExtmessers(int index) {return true;}
1709 public ExternalMessage Extmessers(int index) {
1710 return new ExternalMessage(super.GetExtmessers(index));
1711 }
1712 public Builder AddExtmessers(ExternalMessage value ) {
1713 super.AddExtmessers(value._PBJSuper);
1714 return this;
1715 }
1716 public Builder ClearExtmesser() { super.ClearExtmesser();return this;}
1717 public const int ExtmesserFieldTag=36;
1718 public bool HasExtmesser{ get {return super.HasExtmesser;} }
1719 public ExternalMessage Extmesser{ get {
1720 if (HasExtmesser) {
1721 return new ExternalMessage(super.Extmesser);
1722 } else {
1723 return new ExternalMessage();
1724 }
1725 }
1726 set {
1727 super.Extmesser=value._PBJSuper;
1728 }
1729 }
1730 }
1731 }
1732}
1733namespace Sirikata.PB {
1734}