aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs')
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs431
1 files changed, 0 insertions, 431 deletions
diff --git a/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs
deleted file mode 100644
index c8c2fbf..0000000
--- a/OpenSim/Client/Sirikata/Protocol/Subscription.pbj.cs
+++ /dev/null
@@ -1,431 +0,0 @@
1/*
2 * Copyright (c) Contributors, http://opensimulator.org/
3 * See CONTRIBUTORS.TXT for a full list of copyright holders.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of the OpenSimulator Project nor the
13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28using pbd = global::Google.ProtocolBuffers.Descriptors;
29using pb = global::Google.ProtocolBuffers;
30namespace Sirikata.Subscription.Protocol {
31 public class Address : PBJ.IMessage {
32 protected _PBJ_Internal.Address super;
33 public _PBJ_Internal.Address _PBJSuper{ get { return super;} }
34 public Address() {
35 super=new _PBJ_Internal.Address();
36 }
37 public Address(_PBJ_Internal.Address reference) {
38 super=reference;
39 }
40 public static Address defaultInstance= new Address (_PBJ_Internal.Address.DefaultInstance);
41 public static Address DefaultInstance{
42 get {return defaultInstance;}
43 }
44 public static pbd.MessageDescriptor Descriptor {
45 get { return _PBJ_Internal.Address.Descriptor; } }
46 public static class Types {
47 }
48 public static bool WithinReservedFieldTagRange(int field_tag) {
49 return false;
50 }
51 public static bool WithinExtensionFieldTagRange(int field_tag) {
52 return false;
53 }
54 public const int HostnameFieldTag=1;
55 public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} }
56 public string Hostname{ get {
57 if (HasHostname) {
58 return PBJ._PBJ.CastString(super.Hostname);
59 } else {
60 return PBJ._PBJ.CastString();
61 }
62 }
63 }
64 public const int ServiceFieldTag=2;
65 public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} }
66 public string Service{ get {
67 if (HasService) {
68 return PBJ._PBJ.CastString(super.Service);
69 } else {
70 return PBJ._PBJ.CastString();
71 }
72 }
73 }
74 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
75 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
76 public static Builder CreateBuilder() { return new Builder(); }
77 public static Builder CreateBuilder(Address prototype) {
78 return (Builder)new Builder().MergeFrom(prototype);
79 }
80 public static Address ParseFrom(pb::ByteString data) {
81 return new Address(_PBJ_Internal.Address.ParseFrom(data));
82 }
83 public static Address ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
84 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
85 }
86 public static Address ParseFrom(byte[] data) {
87 return new Address(_PBJ_Internal.Address.ParseFrom(data));
88 }
89 public static Address ParseFrom(byte[] data, pb::ExtensionRegistry er) {
90 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
91 }
92 public static Address ParseFrom(global::System.IO.Stream data) {
93 return new Address(_PBJ_Internal.Address.ParseFrom(data));
94 }
95 public static Address ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
96 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
97 }
98 public static Address ParseFrom(pb::CodedInputStream data) {
99 return new Address(_PBJ_Internal.Address.ParseFrom(data));
100 }
101 public static Address ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
102 return new Address(_PBJ_Internal.Address.ParseFrom(data,er));
103 }
104 protected override bool _HasAllPBJFields{ get {
105 return true
106 ;
107 } }
108 public bool IsInitialized { get {
109 return super.IsInitialized&&_HasAllPBJFields;
110 } }
111 public class Builder : global::PBJ.IMessage.IBuilder{
112 protected override bool _HasAllPBJFields{ get {
113 return true
114 ;
115 } }
116 public bool IsInitialized { get {
117 return super.IsInitialized&&_HasAllPBJFields;
118 } }
119 protected _PBJ_Internal.Address.Builder super;
120 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
121 public _PBJ_Internal.Address.Builder _PBJSuper{ get { return super;} }
122 public Builder() {super = new _PBJ_Internal.Address.Builder();}
123 public Builder(_PBJ_Internal.Address.Builder other) {
124 super=other;
125 }
126 public Builder Clone() {return new Builder(super.Clone());}
127 public Builder MergeFrom(Address prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
128 public Builder Clear() {super.Clear();return this;}
129 public Address BuildPartial() {return new Address(super.BuildPartial());}
130 public Address Build() {if (_HasAllPBJFields) return new Address(super.Build());return null;}
131 public pbd::MessageDescriptor DescriptorForType {
132 get { return Address.Descriptor; } }
133 public Builder ClearHostname() { super.ClearHostname();return this;}
134 public const int HostnameFieldTag=1;
135 public bool HasHostname{ get {return super.HasHostname&&PBJ._PBJ.ValidateString(super.Hostname);} }
136 public string Hostname{ get {
137 if (HasHostname) {
138 return PBJ._PBJ.CastString(super.Hostname);
139 } else {
140 return PBJ._PBJ.CastString();
141 }
142 }
143 set {
144 super.Hostname=(PBJ._PBJ.Construct(value));
145 }
146 }
147 public Builder ClearService() { super.ClearService();return this;}
148 public const int ServiceFieldTag=2;
149 public bool HasService{ get {return super.HasService&&PBJ._PBJ.ValidateString(super.Service);} }
150 public string Service{ get {
151 if (HasService) {
152 return PBJ._PBJ.CastString(super.Service);
153 } else {
154 return PBJ._PBJ.CastString();
155 }
156 }
157 set {
158 super.Service=(PBJ._PBJ.Construct(value));
159 }
160 }
161 }
162 }
163}
164namespace Sirikata.Subscription.Protocol {
165 public class Subscribe : PBJ.IMessage {
166 protected _PBJ_Internal.Subscribe super;
167 public _PBJ_Internal.Subscribe _PBJSuper{ get { return super;} }
168 public Subscribe() {
169 super=new _PBJ_Internal.Subscribe();
170 }
171 public Subscribe(_PBJ_Internal.Subscribe reference) {
172 super=reference;
173 }
174 public static Subscribe defaultInstance= new Subscribe (_PBJ_Internal.Subscribe.DefaultInstance);
175 public static Subscribe DefaultInstance{
176 get {return defaultInstance;}
177 }
178 public static pbd.MessageDescriptor Descriptor {
179 get { return _PBJ_Internal.Subscribe.Descriptor; } }
180 public static class Types {
181 }
182 public static bool WithinReservedFieldTagRange(int field_tag) {
183 return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
184 }
185 public static bool WithinExtensionFieldTagRange(int field_tag) {
186 return false;
187 }
188 public const int BroadcastAddressFieldTag=7;
189 public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} }
190 public Address BroadcastAddress{ get {
191 if (HasBroadcastAddress) {
192 return new Address(super.BroadcastAddress);
193 } else {
194 return new Address();
195 }
196 }
197 }
198 public const int BroadcastNameFieldTag=8;
199 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
200 public PBJ.UUID BroadcastName{ get {
201 if (HasBroadcastName) {
202 return PBJ._PBJ.CastUuid(super.BroadcastName);
203 } else {
204 return PBJ._PBJ.CastUuid();
205 }
206 }
207 }
208 public const int UpdatePeriodFieldTag=9;
209 public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} }
210 public PBJ.Duration UpdatePeriod{ get {
211 if (HasUpdatePeriod) {
212 return PBJ._PBJ.CastDuration(super.UpdatePeriod);
213 } else {
214 return PBJ._PBJ.CastDuration();
215 }
216 }
217 }
218 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
219 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
220 public static Builder CreateBuilder() { return new Builder(); }
221 public static Builder CreateBuilder(Subscribe prototype) {
222 return (Builder)new Builder().MergeFrom(prototype);
223 }
224 public static Subscribe ParseFrom(pb::ByteString data) {
225 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
226 }
227 public static Subscribe ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
228 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
229 }
230 public static Subscribe ParseFrom(byte[] data) {
231 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
232 }
233 public static Subscribe ParseFrom(byte[] data, pb::ExtensionRegistry er) {
234 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
235 }
236 public static Subscribe ParseFrom(global::System.IO.Stream data) {
237 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
238 }
239 public static Subscribe ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
240 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
241 }
242 public static Subscribe ParseFrom(pb::CodedInputStream data) {
243 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data));
244 }
245 public static Subscribe ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
246 return new Subscribe(_PBJ_Internal.Subscribe.ParseFrom(data,er));
247 }
248 protected override bool _HasAllPBJFields{ get {
249 return true
250 ;
251 } }
252 public bool IsInitialized { get {
253 return super.IsInitialized&&_HasAllPBJFields;
254 } }
255 public class Builder : global::PBJ.IMessage.IBuilder{
256 protected override bool _HasAllPBJFields{ get {
257 return true
258 ;
259 } }
260 public bool IsInitialized { get {
261 return super.IsInitialized&&_HasAllPBJFields;
262 } }
263 protected _PBJ_Internal.Subscribe.Builder super;
264 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
265 public _PBJ_Internal.Subscribe.Builder _PBJSuper{ get { return super;} }
266 public Builder() {super = new _PBJ_Internal.Subscribe.Builder();}
267 public Builder(_PBJ_Internal.Subscribe.Builder other) {
268 super=other;
269 }
270 public Builder Clone() {return new Builder(super.Clone());}
271 public Builder MergeFrom(Subscribe prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
272 public Builder Clear() {super.Clear();return this;}
273 public Subscribe BuildPartial() {return new Subscribe(super.BuildPartial());}
274 public Subscribe Build() {if (_HasAllPBJFields) return new Subscribe(super.Build());return null;}
275 public pbd::MessageDescriptor DescriptorForType {
276 get { return Subscribe.Descriptor; } }
277 public Builder ClearBroadcastAddress() { super.ClearBroadcastAddress();return this;}
278 public const int BroadcastAddressFieldTag=7;
279 public bool HasBroadcastAddress{ get {return super.HasBroadcastAddress;} }
280 public Address BroadcastAddress{ get {
281 if (HasBroadcastAddress) {
282 return new Address(super.BroadcastAddress);
283 } else {
284 return new Address();
285 }
286 }
287 set {
288 super.BroadcastAddress=value._PBJSuper;
289 }
290 }
291 public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;}
292 public const int BroadcastNameFieldTag=8;
293 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
294 public PBJ.UUID BroadcastName{ get {
295 if (HasBroadcastName) {
296 return PBJ._PBJ.CastUuid(super.BroadcastName);
297 } else {
298 return PBJ._PBJ.CastUuid();
299 }
300 }
301 set {
302 super.BroadcastName=(PBJ._PBJ.Construct(value));
303 }
304 }
305 public Builder ClearUpdatePeriod() { super.ClearUpdatePeriod();return this;}
306 public const int UpdatePeriodFieldTag=9;
307 public bool HasUpdatePeriod{ get {return super.HasUpdatePeriod&&PBJ._PBJ.ValidateDuration(super.UpdatePeriod);} }
308 public PBJ.Duration UpdatePeriod{ get {
309 if (HasUpdatePeriod) {
310 return PBJ._PBJ.CastDuration(super.UpdatePeriod);
311 } else {
312 return PBJ._PBJ.CastDuration();
313 }
314 }
315 set {
316 super.UpdatePeriod=(PBJ._PBJ.Construct(value));
317 }
318 }
319 }
320 }
321}
322namespace Sirikata.Subscription.Protocol {
323 public class Broadcast : PBJ.IMessage {
324 protected _PBJ_Internal.Broadcast super;
325 public _PBJ_Internal.Broadcast _PBJSuper{ get { return super;} }
326 public Broadcast() {
327 super=new _PBJ_Internal.Broadcast();
328 }
329 public Broadcast(_PBJ_Internal.Broadcast reference) {
330 super=reference;
331 }
332 public static Broadcast defaultInstance= new Broadcast (_PBJ_Internal.Broadcast.DefaultInstance);
333 public static Broadcast DefaultInstance{
334 get {return defaultInstance;}
335 }
336 public static pbd.MessageDescriptor Descriptor {
337 get { return _PBJ_Internal.Broadcast.Descriptor; } }
338 public static class Types {
339 }
340 public static bool WithinReservedFieldTagRange(int field_tag) {
341 return false||(field_tag>=1&&field_tag<=6)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
342 }
343 public static bool WithinExtensionFieldTagRange(int field_tag) {
344 return false;
345 }
346 public const int BroadcastNameFieldTag=7;
347 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
348 public PBJ.UUID BroadcastName{ get {
349 if (HasBroadcastName) {
350 return PBJ._PBJ.CastUuid(super.BroadcastName);
351 } else {
352 return PBJ._PBJ.CastUuid();
353 }
354 }
355 }
356 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
357 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
358 public static Builder CreateBuilder() { return new Builder(); }
359 public static Builder CreateBuilder(Broadcast prototype) {
360 return (Builder)new Builder().MergeFrom(prototype);
361 }
362 public static Broadcast ParseFrom(pb::ByteString data) {
363 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
364 }
365 public static Broadcast ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
366 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
367 }
368 public static Broadcast ParseFrom(byte[] data) {
369 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
370 }
371 public static Broadcast ParseFrom(byte[] data, pb::ExtensionRegistry er) {
372 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
373 }
374 public static Broadcast ParseFrom(global::System.IO.Stream data) {
375 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
376 }
377 public static Broadcast ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
378 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
379 }
380 public static Broadcast ParseFrom(pb::CodedInputStream data) {
381 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data));
382 }
383 public static Broadcast ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
384 return new Broadcast(_PBJ_Internal.Broadcast.ParseFrom(data,er));
385 }
386 protected override bool _HasAllPBJFields{ get {
387 return true
388 ;
389 } }
390 public bool IsInitialized { get {
391 return super.IsInitialized&&_HasAllPBJFields;
392 } }
393 public class Builder : global::PBJ.IMessage.IBuilder{
394 protected override bool _HasAllPBJFields{ get {
395 return true
396 ;
397 } }
398 public bool IsInitialized { get {
399 return super.IsInitialized&&_HasAllPBJFields;
400 } }
401 protected _PBJ_Internal.Broadcast.Builder super;
402 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
403 public _PBJ_Internal.Broadcast.Builder _PBJSuper{ get { return super;} }
404 public Builder() {super = new _PBJ_Internal.Broadcast.Builder();}
405 public Builder(_PBJ_Internal.Broadcast.Builder other) {
406 super=other;
407 }
408 public Builder Clone() {return new Builder(super.Clone());}
409 public Builder MergeFrom(Broadcast prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
410 public Builder Clear() {super.Clear();return this;}
411 public Broadcast BuildPartial() {return new Broadcast(super.BuildPartial());}
412 public Broadcast Build() {if (_HasAllPBJFields) return new Broadcast(super.Build());return null;}
413 public pbd::MessageDescriptor DescriptorForType {
414 get { return Broadcast.Descriptor; } }
415 public Builder ClearBroadcastName() { super.ClearBroadcastName();return this;}
416 public const int BroadcastNameFieldTag=7;
417 public bool HasBroadcastName{ get {return super.HasBroadcastName&&PBJ._PBJ.ValidateUuid(super.BroadcastName);} }
418 public PBJ.UUID BroadcastName{ get {
419 if (HasBroadcastName) {
420 return PBJ._PBJ.CastUuid(super.BroadcastName);
421 } else {
422 return PBJ._PBJ.CastUuid();
423 }
424 }
425 set {
426 super.BroadcastName=(PBJ._PBJ.Construct(value));
427 }
428 }
429 }
430 }
431}
generated by cgit v1.1 at 2024-09-01 01:45:54 +0000