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