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