aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs
diff options
context:
space:
mode:
authorMelanie2010-10-06 00:20:41 +0100
committerMelanie2010-10-06 00:20:41 +0100
commit7e6a04776911c8d738eeb32a1d44397981147b63 (patch)
tree5c0ea909128fe5bffe9bc9d8f0f3153894f0b34d /OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs
parentAdd the view generating method to the image generator interface (diff)
downloadopensim-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/Persistence.pbj.cs1543
1 files changed, 0 insertions, 1543 deletions
diff --git a/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs
deleted file mode 100644
index 196b0b9..0000000
--- a/OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs
+++ /dev/null
@@ -1,1543 +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.Persistence.Protocol {
31 public class StorageKey : PBJ.IMessage {
32 protected _PBJ_Internal.StorageKey super;
33 public _PBJ_Internal.StorageKey _PBJSuper{ get { return super;} }
34 public StorageKey() {
35 super=new _PBJ_Internal.StorageKey();
36 }
37 public StorageKey(_PBJ_Internal.StorageKey reference) {
38 super=reference;
39 }
40 public static StorageKey defaultInstance= new StorageKey (_PBJ_Internal.StorageKey.DefaultInstance);
41 public static StorageKey DefaultInstance{
42 get {return defaultInstance;}
43 }
44 public static pbd.MessageDescriptor Descriptor {
45 get { return _PBJ_Internal.StorageKey.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 ObjectUuidFieldTag=9;
55 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
56 public PBJ.UUID ObjectUuid{ get {
57 if (HasObjectUuid) {
58 return PBJ._PBJ.CastUuid(super.ObjectUuid);
59 } else {
60 return PBJ._PBJ.CastUuid();
61 }
62 }
63 }
64 public const int FieldIdFieldTag=10;
65 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
66 public ulong FieldId{ get {
67 if (HasFieldId) {
68 return PBJ._PBJ.CastUint64(super.FieldId);
69 } else {
70 return PBJ._PBJ.CastUint64();
71 }
72 }
73 }
74 public const int FieldNameFieldTag=11;
75 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
76 public string FieldName{ get {
77 if (HasFieldName) {
78 return PBJ._PBJ.CastString(super.FieldName);
79 } else {
80 return PBJ._PBJ.CastString();
81 }
82 }
83 }
84 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
85 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
86 public static Builder CreateBuilder() { return new Builder(); }
87 public static Builder CreateBuilder(StorageKey prototype) {
88 return (Builder)new Builder().MergeFrom(prototype);
89 }
90 public static StorageKey ParseFrom(pb::ByteString data) {
91 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
92 }
93 public static StorageKey ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
94 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
95 }
96 public static StorageKey ParseFrom(byte[] data) {
97 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
98 }
99 public static StorageKey ParseFrom(byte[] data, pb::ExtensionRegistry er) {
100 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
101 }
102 public static StorageKey ParseFrom(global::System.IO.Stream data) {
103 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
104 }
105 public static StorageKey ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
106 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
107 }
108 public static StorageKey ParseFrom(pb::CodedInputStream data) {
109 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data));
110 }
111 public static StorageKey ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
112 return new StorageKey(_PBJ_Internal.StorageKey.ParseFrom(data,er));
113 }
114 protected override bool _HasAllPBJFields{ get {
115 return true
116 ;
117 } }
118 public bool IsInitialized { get {
119 return super.IsInitialized&&_HasAllPBJFields;
120 } }
121 public class Builder : global::PBJ.IMessage.IBuilder{
122 protected override bool _HasAllPBJFields{ get {
123 return true
124 ;
125 } }
126 public bool IsInitialized { get {
127 return super.IsInitialized&&_HasAllPBJFields;
128 } }
129 protected _PBJ_Internal.StorageKey.Builder super;
130 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
131 public _PBJ_Internal.StorageKey.Builder _PBJSuper{ get { return super;} }
132 public Builder() {super = new _PBJ_Internal.StorageKey.Builder();}
133 public Builder(_PBJ_Internal.StorageKey.Builder other) {
134 super=other;
135 }
136 public Builder Clone() {return new Builder(super.Clone());}
137 public Builder MergeFrom(StorageKey prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
138 public Builder Clear() {super.Clear();return this;}
139 public StorageKey BuildPartial() {return new StorageKey(super.BuildPartial());}
140 public StorageKey Build() {if (_HasAllPBJFields) return new StorageKey(super.Build());return null;}
141 public pbd::MessageDescriptor DescriptorForType {
142 get { return StorageKey.Descriptor; } }
143 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
144 public const int ObjectUuidFieldTag=9;
145 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
146 public PBJ.UUID ObjectUuid{ get {
147 if (HasObjectUuid) {
148 return PBJ._PBJ.CastUuid(super.ObjectUuid);
149 } else {
150 return PBJ._PBJ.CastUuid();
151 }
152 }
153 set {
154 super.ObjectUuid=(PBJ._PBJ.Construct(value));
155 }
156 }
157 public Builder ClearFieldId() { super.ClearFieldId();return this;}
158 public const int FieldIdFieldTag=10;
159 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
160 public ulong FieldId{ get {
161 if (HasFieldId) {
162 return PBJ._PBJ.CastUint64(super.FieldId);
163 } else {
164 return PBJ._PBJ.CastUint64();
165 }
166 }
167 set {
168 super.FieldId=(PBJ._PBJ.Construct(value));
169 }
170 }
171 public Builder ClearFieldName() { super.ClearFieldName();return this;}
172 public const int FieldNameFieldTag=11;
173 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
174 public string FieldName{ get {
175 if (HasFieldName) {
176 return PBJ._PBJ.CastString(super.FieldName);
177 } else {
178 return PBJ._PBJ.CastString();
179 }
180 }
181 set {
182 super.FieldName=(PBJ._PBJ.Construct(value));
183 }
184 }
185 }
186 }
187}
188namespace Sirikata.Persistence.Protocol {
189 public class StorageValue : PBJ.IMessage {
190 protected _PBJ_Internal.StorageValue super;
191 public _PBJ_Internal.StorageValue _PBJSuper{ get { return super;} }
192 public StorageValue() {
193 super=new _PBJ_Internal.StorageValue();
194 }
195 public StorageValue(_PBJ_Internal.StorageValue reference) {
196 super=reference;
197 }
198 public static StorageValue defaultInstance= new StorageValue (_PBJ_Internal.StorageValue.DefaultInstance);
199 public static StorageValue DefaultInstance{
200 get {return defaultInstance;}
201 }
202 public static pbd.MessageDescriptor Descriptor {
203 get { return _PBJ_Internal.StorageValue.Descriptor; } }
204 public static class Types {
205 }
206 public static bool WithinReservedFieldTagRange(int field_tag) {
207 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
208 }
209 public static bool WithinExtensionFieldTagRange(int field_tag) {
210 return false;
211 }
212 public const int DataFieldTag=12;
213 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
214 public pb::ByteString Data{ get {
215 if (HasData) {
216 return PBJ._PBJ.CastBytes(super.Data);
217 } else {
218 return PBJ._PBJ.CastBytes();
219 }
220 }
221 }
222 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
223 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
224 public static Builder CreateBuilder() { return new Builder(); }
225 public static Builder CreateBuilder(StorageValue prototype) {
226 return (Builder)new Builder().MergeFrom(prototype);
227 }
228 public static StorageValue ParseFrom(pb::ByteString data) {
229 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
230 }
231 public static StorageValue ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
232 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
233 }
234 public static StorageValue ParseFrom(byte[] data) {
235 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
236 }
237 public static StorageValue ParseFrom(byte[] data, pb::ExtensionRegistry er) {
238 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
239 }
240 public static StorageValue ParseFrom(global::System.IO.Stream data) {
241 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
242 }
243 public static StorageValue ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
244 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
245 }
246 public static StorageValue ParseFrom(pb::CodedInputStream data) {
247 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data));
248 }
249 public static StorageValue ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
250 return new StorageValue(_PBJ_Internal.StorageValue.ParseFrom(data,er));
251 }
252 protected override bool _HasAllPBJFields{ get {
253 return true
254 ;
255 } }
256 public bool IsInitialized { get {
257 return super.IsInitialized&&_HasAllPBJFields;
258 } }
259 public class Builder : global::PBJ.IMessage.IBuilder{
260 protected override bool _HasAllPBJFields{ get {
261 return true
262 ;
263 } }
264 public bool IsInitialized { get {
265 return super.IsInitialized&&_HasAllPBJFields;
266 } }
267 protected _PBJ_Internal.StorageValue.Builder super;
268 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
269 public _PBJ_Internal.StorageValue.Builder _PBJSuper{ get { return super;} }
270 public Builder() {super = new _PBJ_Internal.StorageValue.Builder();}
271 public Builder(_PBJ_Internal.StorageValue.Builder other) {
272 super=other;
273 }
274 public Builder Clone() {return new Builder(super.Clone());}
275 public Builder MergeFrom(StorageValue prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
276 public Builder Clear() {super.Clear();return this;}
277 public StorageValue BuildPartial() {return new StorageValue(super.BuildPartial());}
278 public StorageValue Build() {if (_HasAllPBJFields) return new StorageValue(super.Build());return null;}
279 public pbd::MessageDescriptor DescriptorForType {
280 get { return StorageValue.Descriptor; } }
281 public Builder ClearData() { super.ClearData();return this;}
282 public const int DataFieldTag=12;
283 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
284 public pb::ByteString Data{ get {
285 if (HasData) {
286 return PBJ._PBJ.CastBytes(super.Data);
287 } else {
288 return PBJ._PBJ.CastBytes();
289 }
290 }
291 set {
292 super.Data=(PBJ._PBJ.Construct(value));
293 }
294 }
295 }
296 }
297}
298namespace Sirikata.Persistence.Protocol {
299 public class StorageElement : PBJ.IMessage {
300 protected _PBJ_Internal.StorageElement super;
301 public _PBJ_Internal.StorageElement _PBJSuper{ get { return super;} }
302 public StorageElement() {
303 super=new _PBJ_Internal.StorageElement();
304 }
305 public StorageElement(_PBJ_Internal.StorageElement reference) {
306 super=reference;
307 }
308 public static StorageElement defaultInstance= new StorageElement (_PBJ_Internal.StorageElement.DefaultInstance);
309 public static StorageElement DefaultInstance{
310 get {return defaultInstance;}
311 }
312 public static pbd.MessageDescriptor Descriptor {
313 get { return _PBJ_Internal.StorageElement.Descriptor; } }
314 public static class Types {
315 public enum ReturnStatus {
316 KEY_MISSING=_PBJ_Internal.StorageElement.Types.ReturnStatus.KEY_MISSING,
317 INTERNAL_ERROR=_PBJ_Internal.StorageElement.Types.ReturnStatus.INTERNAL_ERROR
318 };
319 }
320 public static bool WithinReservedFieldTagRange(int field_tag) {
321 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
322 }
323 public static bool WithinExtensionFieldTagRange(int field_tag) {
324 return false;
325 }
326 public const int ObjectUuidFieldTag=9;
327 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
328 public PBJ.UUID ObjectUuid{ get {
329 if (HasObjectUuid) {
330 return PBJ._PBJ.CastUuid(super.ObjectUuid);
331 } else {
332 return PBJ._PBJ.CastUuid();
333 }
334 }
335 }
336 public const int FieldIdFieldTag=10;
337 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
338 public ulong FieldId{ get {
339 if (HasFieldId) {
340 return PBJ._PBJ.CastUint64(super.FieldId);
341 } else {
342 return PBJ._PBJ.CastUint64();
343 }
344 }
345 }
346 public const int FieldNameFieldTag=11;
347 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
348 public string FieldName{ get {
349 if (HasFieldName) {
350 return PBJ._PBJ.CastString(super.FieldName);
351 } else {
352 return PBJ._PBJ.CastString();
353 }
354 }
355 }
356 public const int DataFieldTag=12;
357 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
358 public pb::ByteString Data{ get {
359 if (HasData) {
360 return PBJ._PBJ.CastBytes(super.Data);
361 } else {
362 return PBJ._PBJ.CastBytes();
363 }
364 }
365 }
366 public const int IndexFieldTag=13;
367 public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} }
368 public int Index{ get {
369 if (HasIndex) {
370 return PBJ._PBJ.CastInt32(super.Index);
371 } else {
372 return PBJ._PBJ.CastInt32();
373 }
374 }
375 }
376 public const int ReturnStatusFieldTag=15;
377 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
378 public Types.ReturnStatus ReturnStatus{ get {
379 if (HasReturnStatus) {
380 return (Types.ReturnStatus)super.ReturnStatus;
381 } else {
382 return new Types.ReturnStatus();
383 }
384 }
385 }
386 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
387 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
388 public static Builder CreateBuilder() { return new Builder(); }
389 public static Builder CreateBuilder(StorageElement prototype) {
390 return (Builder)new Builder().MergeFrom(prototype);
391 }
392 public static StorageElement ParseFrom(pb::ByteString data) {
393 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
394 }
395 public static StorageElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
396 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
397 }
398 public static StorageElement ParseFrom(byte[] data) {
399 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
400 }
401 public static StorageElement ParseFrom(byte[] data, pb::ExtensionRegistry er) {
402 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
403 }
404 public static StorageElement ParseFrom(global::System.IO.Stream data) {
405 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
406 }
407 public static StorageElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
408 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
409 }
410 public static StorageElement ParseFrom(pb::CodedInputStream data) {
411 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data));
412 }
413 public static StorageElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
414 return new StorageElement(_PBJ_Internal.StorageElement.ParseFrom(data,er));
415 }
416 protected override bool _HasAllPBJFields{ get {
417 return true
418 ;
419 } }
420 public bool IsInitialized { get {
421 return super.IsInitialized&&_HasAllPBJFields;
422 } }
423 public class Builder : global::PBJ.IMessage.IBuilder{
424 protected override bool _HasAllPBJFields{ get {
425 return true
426 ;
427 } }
428 public bool IsInitialized { get {
429 return super.IsInitialized&&_HasAllPBJFields;
430 } }
431 protected _PBJ_Internal.StorageElement.Builder super;
432 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
433 public _PBJ_Internal.StorageElement.Builder _PBJSuper{ get { return super;} }
434 public Builder() {super = new _PBJ_Internal.StorageElement.Builder();}
435 public Builder(_PBJ_Internal.StorageElement.Builder other) {
436 super=other;
437 }
438 public Builder Clone() {return new Builder(super.Clone());}
439 public Builder MergeFrom(StorageElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
440 public Builder Clear() {super.Clear();return this;}
441 public StorageElement BuildPartial() {return new StorageElement(super.BuildPartial());}
442 public StorageElement Build() {if (_HasAllPBJFields) return new StorageElement(super.Build());return null;}
443 public pbd::MessageDescriptor DescriptorForType {
444 get { return StorageElement.Descriptor; } }
445 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
446 public const int ObjectUuidFieldTag=9;
447 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
448 public PBJ.UUID ObjectUuid{ get {
449 if (HasObjectUuid) {
450 return PBJ._PBJ.CastUuid(super.ObjectUuid);
451 } else {
452 return PBJ._PBJ.CastUuid();
453 }
454 }
455 set {
456 super.ObjectUuid=(PBJ._PBJ.Construct(value));
457 }
458 }
459 public Builder ClearFieldId() { super.ClearFieldId();return this;}
460 public const int FieldIdFieldTag=10;
461 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
462 public ulong FieldId{ get {
463 if (HasFieldId) {
464 return PBJ._PBJ.CastUint64(super.FieldId);
465 } else {
466 return PBJ._PBJ.CastUint64();
467 }
468 }
469 set {
470 super.FieldId=(PBJ._PBJ.Construct(value));
471 }
472 }
473 public Builder ClearFieldName() { super.ClearFieldName();return this;}
474 public const int FieldNameFieldTag=11;
475 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
476 public string FieldName{ get {
477 if (HasFieldName) {
478 return PBJ._PBJ.CastString(super.FieldName);
479 } else {
480 return PBJ._PBJ.CastString();
481 }
482 }
483 set {
484 super.FieldName=(PBJ._PBJ.Construct(value));
485 }
486 }
487 public Builder ClearData() { super.ClearData();return this;}
488 public const int DataFieldTag=12;
489 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
490 public pb::ByteString Data{ get {
491 if (HasData) {
492 return PBJ._PBJ.CastBytes(super.Data);
493 } else {
494 return PBJ._PBJ.CastBytes();
495 }
496 }
497 set {
498 super.Data=(PBJ._PBJ.Construct(value));
499 }
500 }
501 public Builder ClearIndex() { super.ClearIndex();return this;}
502 public const int IndexFieldTag=13;
503 public bool HasIndex{ get {return super.HasIndex&&PBJ._PBJ.ValidateInt32(super.Index);} }
504 public int Index{ get {
505 if (HasIndex) {
506 return PBJ._PBJ.CastInt32(super.Index);
507 } else {
508 return PBJ._PBJ.CastInt32();
509 }
510 }
511 set {
512 super.Index=(PBJ._PBJ.Construct(value));
513 }
514 }
515 public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;}
516 public const int ReturnStatusFieldTag=15;
517 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
518 public Types.ReturnStatus ReturnStatus{ get {
519 if (HasReturnStatus) {
520 return (Types.ReturnStatus)super.ReturnStatus;
521 } else {
522 return new Types.ReturnStatus();
523 }
524 }
525 set {
526 super.ReturnStatus=((_PBJ_Internal.StorageElement.Types.ReturnStatus)value);
527 }
528 }
529 }
530 }
531}
532namespace Sirikata.Persistence.Protocol {
533 public class CompareElement : PBJ.IMessage {
534 protected _PBJ_Internal.CompareElement super;
535 public _PBJ_Internal.CompareElement _PBJSuper{ get { return super;} }
536 public CompareElement() {
537 super=new _PBJ_Internal.CompareElement();
538 }
539 public CompareElement(_PBJ_Internal.CompareElement reference) {
540 super=reference;
541 }
542 public static CompareElement defaultInstance= new CompareElement (_PBJ_Internal.CompareElement.DefaultInstance);
543 public static CompareElement DefaultInstance{
544 get {return defaultInstance;}
545 }
546 public static pbd.MessageDescriptor Descriptor {
547 get { return _PBJ_Internal.CompareElement.Descriptor; } }
548 public static class Types {
549 public enum COMPARATOR {
550 EQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.EQUAL,
551 NEQUAL=_PBJ_Internal.CompareElement.Types.COMPARATOR.NEQUAL
552 };
553 }
554 public static bool WithinReservedFieldTagRange(int field_tag) {
555 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
556 }
557 public static bool WithinExtensionFieldTagRange(int field_tag) {
558 return false;
559 }
560 public const int ObjectUuidFieldTag=9;
561 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
562 public PBJ.UUID ObjectUuid{ get {
563 if (HasObjectUuid) {
564 return PBJ._PBJ.CastUuid(super.ObjectUuid);
565 } else {
566 return PBJ._PBJ.CastUuid();
567 }
568 }
569 }
570 public const int FieldIdFieldTag=10;
571 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
572 public ulong FieldId{ get {
573 if (HasFieldId) {
574 return PBJ._PBJ.CastUint64(super.FieldId);
575 } else {
576 return PBJ._PBJ.CastUint64();
577 }
578 }
579 }
580 public const int FieldNameFieldTag=11;
581 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
582 public string FieldName{ get {
583 if (HasFieldName) {
584 return PBJ._PBJ.CastString(super.FieldName);
585 } else {
586 return PBJ._PBJ.CastString();
587 }
588 }
589 }
590 public const int DataFieldTag=12;
591 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
592 public pb::ByteString Data{ get {
593 if (HasData) {
594 return PBJ._PBJ.CastBytes(super.Data);
595 } else {
596 return PBJ._PBJ.CastBytes();
597 }
598 }
599 }
600 public const int ComparatorFieldTag=14;
601 public bool HasComparator{ get {return super.HasComparator;} }
602 public Types.COMPARATOR Comparator{ get {
603 if (HasComparator) {
604 return (Types.COMPARATOR)super.Comparator;
605 } else {
606 return new Types.COMPARATOR();
607 }
608 }
609 }
610 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
611 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
612 public static Builder CreateBuilder() { return new Builder(); }
613 public static Builder CreateBuilder(CompareElement prototype) {
614 return (Builder)new Builder().MergeFrom(prototype);
615 }
616 public static CompareElement ParseFrom(pb::ByteString data) {
617 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
618 }
619 public static CompareElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
620 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
621 }
622 public static CompareElement ParseFrom(byte[] data) {
623 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
624 }
625 public static CompareElement ParseFrom(byte[] data, pb::ExtensionRegistry er) {
626 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
627 }
628 public static CompareElement ParseFrom(global::System.IO.Stream data) {
629 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
630 }
631 public static CompareElement ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
632 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
633 }
634 public static CompareElement ParseFrom(pb::CodedInputStream data) {
635 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data));
636 }
637 public static CompareElement ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
638 return new CompareElement(_PBJ_Internal.CompareElement.ParseFrom(data,er));
639 }
640 protected override bool _HasAllPBJFields{ get {
641 return true
642 ;
643 } }
644 public bool IsInitialized { get {
645 return super.IsInitialized&&_HasAllPBJFields;
646 } }
647 public class Builder : global::PBJ.IMessage.IBuilder{
648 protected override bool _HasAllPBJFields{ get {
649 return true
650 ;
651 } }
652 public bool IsInitialized { get {
653 return super.IsInitialized&&_HasAllPBJFields;
654 } }
655 protected _PBJ_Internal.CompareElement.Builder super;
656 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
657 public _PBJ_Internal.CompareElement.Builder _PBJSuper{ get { return super;} }
658 public Builder() {super = new _PBJ_Internal.CompareElement.Builder();}
659 public Builder(_PBJ_Internal.CompareElement.Builder other) {
660 super=other;
661 }
662 public Builder Clone() {return new Builder(super.Clone());}
663 public Builder MergeFrom(CompareElement prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
664 public Builder Clear() {super.Clear();return this;}
665 public CompareElement BuildPartial() {return new CompareElement(super.BuildPartial());}
666 public CompareElement Build() {if (_HasAllPBJFields) return new CompareElement(super.Build());return null;}
667 public pbd::MessageDescriptor DescriptorForType {
668 get { return CompareElement.Descriptor; } }
669 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
670 public const int ObjectUuidFieldTag=9;
671 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
672 public PBJ.UUID ObjectUuid{ get {
673 if (HasObjectUuid) {
674 return PBJ._PBJ.CastUuid(super.ObjectUuid);
675 } else {
676 return PBJ._PBJ.CastUuid();
677 }
678 }
679 set {
680 super.ObjectUuid=(PBJ._PBJ.Construct(value));
681 }
682 }
683 public Builder ClearFieldId() { super.ClearFieldId();return this;}
684 public const int FieldIdFieldTag=10;
685 public bool HasFieldId{ get {return super.HasFieldId&&PBJ._PBJ.ValidateUint64(super.FieldId);} }
686 public ulong FieldId{ get {
687 if (HasFieldId) {
688 return PBJ._PBJ.CastUint64(super.FieldId);
689 } else {
690 return PBJ._PBJ.CastUint64();
691 }
692 }
693 set {
694 super.FieldId=(PBJ._PBJ.Construct(value));
695 }
696 }
697 public Builder ClearFieldName() { super.ClearFieldName();return this;}
698 public const int FieldNameFieldTag=11;
699 public bool HasFieldName{ get {return super.HasFieldName&&PBJ._PBJ.ValidateString(super.FieldName);} }
700 public string FieldName{ get {
701 if (HasFieldName) {
702 return PBJ._PBJ.CastString(super.FieldName);
703 } else {
704 return PBJ._PBJ.CastString();
705 }
706 }
707 set {
708 super.FieldName=(PBJ._PBJ.Construct(value));
709 }
710 }
711 public Builder ClearData() { super.ClearData();return this;}
712 public const int DataFieldTag=12;
713 public bool HasData{ get {return super.HasData&&PBJ._PBJ.ValidateBytes(super.Data);} }
714 public pb::ByteString Data{ get {
715 if (HasData) {
716 return PBJ._PBJ.CastBytes(super.Data);
717 } else {
718 return PBJ._PBJ.CastBytes();
719 }
720 }
721 set {
722 super.Data=(PBJ._PBJ.Construct(value));
723 }
724 }
725 public Builder ClearComparator() { super.ClearComparator();return this;}
726 public const int ComparatorFieldTag=14;
727 public bool HasComparator{ get {return super.HasComparator;} }
728 public Types.COMPARATOR Comparator{ get {
729 if (HasComparator) {
730 return (Types.COMPARATOR)super.Comparator;
731 } else {
732 return new Types.COMPARATOR();
733 }
734 }
735 set {
736 super.Comparator=((_PBJ_Internal.CompareElement.Types.COMPARATOR)value);
737 }
738 }
739 }
740 }
741}
742namespace Sirikata.Persistence.Protocol {
743 public class StorageSet : PBJ.IMessage {
744 protected _PBJ_Internal.StorageSet super;
745 public _PBJ_Internal.StorageSet _PBJSuper{ get { return super;} }
746 public StorageSet() {
747 super=new _PBJ_Internal.StorageSet();
748 }
749 public StorageSet(_PBJ_Internal.StorageSet reference) {
750 super=reference;
751 }
752 public static StorageSet defaultInstance= new StorageSet (_PBJ_Internal.StorageSet.DefaultInstance);
753 public static StorageSet DefaultInstance{
754 get {return defaultInstance;}
755 }
756 public static pbd.MessageDescriptor Descriptor {
757 get { return _PBJ_Internal.StorageSet.Descriptor; } }
758 public static class Types {
759 }
760 public static bool WithinReservedFieldTagRange(int field_tag) {
761 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
762 }
763 public static bool WithinExtensionFieldTagRange(int field_tag) {
764 return false;
765 }
766 public const int ReadsFieldTag=9;
767 public int ReadsCount { get { return super.ReadsCount;} }
768 public bool HasReads(int index) {return true;}
769 public StorageElement Reads(int index) {
770 return new StorageElement(super.GetReads(index));
771 }
772 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
773 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
774 public static Builder CreateBuilder() { return new Builder(); }
775 public static Builder CreateBuilder(StorageSet prototype) {
776 return (Builder)new Builder().MergeFrom(prototype);
777 }
778 public static StorageSet ParseFrom(pb::ByteString data) {
779 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
780 }
781 public static StorageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
782 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
783 }
784 public static StorageSet ParseFrom(byte[] data) {
785 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
786 }
787 public static StorageSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
788 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
789 }
790 public static StorageSet ParseFrom(global::System.IO.Stream data) {
791 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
792 }
793 public static StorageSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
794 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
795 }
796 public static StorageSet ParseFrom(pb::CodedInputStream data) {
797 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data));
798 }
799 public static StorageSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
800 return new StorageSet(_PBJ_Internal.StorageSet.ParseFrom(data,er));
801 }
802 protected override bool _HasAllPBJFields{ get {
803 return true
804 ;
805 } }
806 public bool IsInitialized { get {
807 return super.IsInitialized&&_HasAllPBJFields;
808 } }
809 public class Builder : global::PBJ.IMessage.IBuilder{
810 protected override bool _HasAllPBJFields{ get {
811 return true
812 ;
813 } }
814 public bool IsInitialized { get {
815 return super.IsInitialized&&_HasAllPBJFields;
816 } }
817 protected _PBJ_Internal.StorageSet.Builder super;
818 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
819 public _PBJ_Internal.StorageSet.Builder _PBJSuper{ get { return super;} }
820 public Builder() {super = new _PBJ_Internal.StorageSet.Builder();}
821 public Builder(_PBJ_Internal.StorageSet.Builder other) {
822 super=other;
823 }
824 public Builder Clone() {return new Builder(super.Clone());}
825 public Builder MergeFrom(StorageSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
826 public Builder Clear() {super.Clear();return this;}
827 public StorageSet BuildPartial() {return new StorageSet(super.BuildPartial());}
828 public StorageSet Build() {if (_HasAllPBJFields) return new StorageSet(super.Build());return null;}
829 public pbd::MessageDescriptor DescriptorForType {
830 get { return StorageSet.Descriptor; } }
831 public Builder ClearReads() { super.ClearReads();return this;}
832 public Builder SetReads(int index,StorageElement value) {
833 super.SetReads(index,value._PBJSuper);
834 return this;
835 }
836 public const int ReadsFieldTag=9;
837 public int ReadsCount { get { return super.ReadsCount;} }
838 public bool HasReads(int index) {return true;}
839 public StorageElement Reads(int index) {
840 return new StorageElement(super.GetReads(index));
841 }
842 public Builder AddReads(StorageElement value) {
843 super.AddReads(value._PBJSuper);
844 return this;
845 }
846 }
847 }
848}
849namespace Sirikata.Persistence.Protocol {
850 public class ReadSet : PBJ.IMessage {
851 protected _PBJ_Internal.ReadSet super;
852 public _PBJ_Internal.ReadSet _PBJSuper{ get { return super;} }
853 public ReadSet() {
854 super=new _PBJ_Internal.ReadSet();
855 }
856 public ReadSet(_PBJ_Internal.ReadSet reference) {
857 super=reference;
858 }
859 public static ReadSet defaultInstance= new ReadSet (_PBJ_Internal.ReadSet.DefaultInstance);
860 public static ReadSet DefaultInstance{
861 get {return defaultInstance;}
862 }
863 public static pbd.MessageDescriptor Descriptor {
864 get { return _PBJ_Internal.ReadSet.Descriptor; } }
865 public static class Types {
866 }
867 public static bool WithinReservedFieldTagRange(int field_tag) {
868 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
869 }
870 public static bool WithinExtensionFieldTagRange(int field_tag) {
871 return false;
872 }
873 public const int ReadsFieldTag=9;
874 public int ReadsCount { get { return super.ReadsCount;} }
875 public bool HasReads(int index) {return true;}
876 public StorageElement Reads(int index) {
877 return new StorageElement(super.GetReads(index));
878 }
879 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
880 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
881 public static Builder CreateBuilder() { return new Builder(); }
882 public static Builder CreateBuilder(ReadSet prototype) {
883 return (Builder)new Builder().MergeFrom(prototype);
884 }
885 public static ReadSet ParseFrom(pb::ByteString data) {
886 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
887 }
888 public static ReadSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
889 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
890 }
891 public static ReadSet ParseFrom(byte[] data) {
892 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
893 }
894 public static ReadSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
895 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
896 }
897 public static ReadSet ParseFrom(global::System.IO.Stream data) {
898 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
899 }
900 public static ReadSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
901 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
902 }
903 public static ReadSet ParseFrom(pb::CodedInputStream data) {
904 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data));
905 }
906 public static ReadSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
907 return new ReadSet(_PBJ_Internal.ReadSet.ParseFrom(data,er));
908 }
909 protected override bool _HasAllPBJFields{ get {
910 return true
911 ;
912 } }
913 public bool IsInitialized { get {
914 return super.IsInitialized&&_HasAllPBJFields;
915 } }
916 public class Builder : global::PBJ.IMessage.IBuilder{
917 protected override bool _HasAllPBJFields{ get {
918 return true
919 ;
920 } }
921 public bool IsInitialized { get {
922 return super.IsInitialized&&_HasAllPBJFields;
923 } }
924 protected _PBJ_Internal.ReadSet.Builder super;
925 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
926 public _PBJ_Internal.ReadSet.Builder _PBJSuper{ get { return super;} }
927 public Builder() {super = new _PBJ_Internal.ReadSet.Builder();}
928 public Builder(_PBJ_Internal.ReadSet.Builder other) {
929 super=other;
930 }
931 public Builder Clone() {return new Builder(super.Clone());}
932 public Builder MergeFrom(ReadSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
933 public Builder Clear() {super.Clear();return this;}
934 public ReadSet BuildPartial() {return new ReadSet(super.BuildPartial());}
935 public ReadSet Build() {if (_HasAllPBJFields) return new ReadSet(super.Build());return null;}
936 public pbd::MessageDescriptor DescriptorForType {
937 get { return ReadSet.Descriptor; } }
938 public Builder ClearReads() { super.ClearReads();return this;}
939 public Builder SetReads(int index,StorageElement value) {
940 super.SetReads(index,value._PBJSuper);
941 return this;
942 }
943 public const int ReadsFieldTag=9;
944 public int ReadsCount { get { return super.ReadsCount;} }
945 public bool HasReads(int index) {return true;}
946 public StorageElement Reads(int index) {
947 return new StorageElement(super.GetReads(index));
948 }
949 public Builder AddReads(StorageElement value) {
950 super.AddReads(value._PBJSuper);
951 return this;
952 }
953 }
954 }
955}
956namespace Sirikata.Persistence.Protocol {
957 public class WriteSet : PBJ.IMessage {
958 protected _PBJ_Internal.WriteSet super;
959 public _PBJ_Internal.WriteSet _PBJSuper{ get { return super;} }
960 public WriteSet() {
961 super=new _PBJ_Internal.WriteSet();
962 }
963 public WriteSet(_PBJ_Internal.WriteSet reference) {
964 super=reference;
965 }
966 public static WriteSet defaultInstance= new WriteSet (_PBJ_Internal.WriteSet.DefaultInstance);
967 public static WriteSet DefaultInstance{
968 get {return defaultInstance;}
969 }
970 public static pbd.MessageDescriptor Descriptor {
971 get { return _PBJ_Internal.WriteSet.Descriptor; } }
972 public static class Types {
973 }
974 public static bool WithinReservedFieldTagRange(int field_tag) {
975 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
976 }
977 public static bool WithinExtensionFieldTagRange(int field_tag) {
978 return false;
979 }
980 public const int WritesFieldTag=10;
981 public int WritesCount { get { return super.WritesCount;} }
982 public bool HasWrites(int index) {return true;}
983 public StorageElement Writes(int index) {
984 return new StorageElement(super.GetWrites(index));
985 }
986 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
987 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
988 public static Builder CreateBuilder() { return new Builder(); }
989 public static Builder CreateBuilder(WriteSet prototype) {
990 return (Builder)new Builder().MergeFrom(prototype);
991 }
992 public static WriteSet ParseFrom(pb::ByteString data) {
993 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
994 }
995 public static WriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
996 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
997 }
998 public static WriteSet ParseFrom(byte[] data) {
999 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
1000 }
1001 public static WriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1002 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
1003 }
1004 public static WriteSet ParseFrom(global::System.IO.Stream data) {
1005 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
1006 }
1007 public static WriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1008 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
1009 }
1010 public static WriteSet ParseFrom(pb::CodedInputStream data) {
1011 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data));
1012 }
1013 public static WriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1014 return new WriteSet(_PBJ_Internal.WriteSet.ParseFrom(data,er));
1015 }
1016 protected override bool _HasAllPBJFields{ get {
1017 return true
1018 ;
1019 } }
1020 public bool IsInitialized { get {
1021 return super.IsInitialized&&_HasAllPBJFields;
1022 } }
1023 public class Builder : global::PBJ.IMessage.IBuilder{
1024 protected override bool _HasAllPBJFields{ get {
1025 return true
1026 ;
1027 } }
1028 public bool IsInitialized { get {
1029 return super.IsInitialized&&_HasAllPBJFields;
1030 } }
1031 protected _PBJ_Internal.WriteSet.Builder super;
1032 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1033 public _PBJ_Internal.WriteSet.Builder _PBJSuper{ get { return super;} }
1034 public Builder() {super = new _PBJ_Internal.WriteSet.Builder();}
1035 public Builder(_PBJ_Internal.WriteSet.Builder other) {
1036 super=other;
1037 }
1038 public Builder Clone() {return new Builder(super.Clone());}
1039 public Builder MergeFrom(WriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1040 public Builder Clear() {super.Clear();return this;}
1041 public WriteSet BuildPartial() {return new WriteSet(super.BuildPartial());}
1042 public WriteSet Build() {if (_HasAllPBJFields) return new WriteSet(super.Build());return null;}
1043 public pbd::MessageDescriptor DescriptorForType {
1044 get { return WriteSet.Descriptor; } }
1045 public Builder ClearWrites() { super.ClearWrites();return this;}
1046 public Builder SetWrites(int index,StorageElement value) {
1047 super.SetWrites(index,value._PBJSuper);
1048 return this;
1049 }
1050 public const int WritesFieldTag=10;
1051 public int WritesCount { get { return super.WritesCount;} }
1052 public bool HasWrites(int index) {return true;}
1053 public StorageElement Writes(int index) {
1054 return new StorageElement(super.GetWrites(index));
1055 }
1056 public Builder AddWrites(StorageElement value) {
1057 super.AddWrites(value._PBJSuper);
1058 return this;
1059 }
1060 }
1061 }
1062}
1063namespace Sirikata.Persistence.Protocol {
1064 public class ReadWriteSet : PBJ.IMessage {
1065 protected _PBJ_Internal.ReadWriteSet super;
1066 public _PBJ_Internal.ReadWriteSet _PBJSuper{ get { return super;} }
1067 public ReadWriteSet() {
1068 super=new _PBJ_Internal.ReadWriteSet();
1069 }
1070 public ReadWriteSet(_PBJ_Internal.ReadWriteSet reference) {
1071 super=reference;
1072 }
1073 public static ReadWriteSet defaultInstance= new ReadWriteSet (_PBJ_Internal.ReadWriteSet.DefaultInstance);
1074 public static ReadWriteSet DefaultInstance{
1075 get {return defaultInstance;}
1076 }
1077 public static pbd.MessageDescriptor Descriptor {
1078 get { return _PBJ_Internal.ReadWriteSet.Descriptor; } }
1079 public static class Types {
1080 public enum ReadWriteSetOptions {
1081 RETURN_READ_NAMES=_PBJ_Internal.ReadWriteSet.Types.ReadWriteSetOptions.RETURN_READ_NAMES
1082 };
1083 }
1084 public static bool WithinReservedFieldTagRange(int field_tag) {
1085 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
1086 }
1087 public static bool WithinExtensionFieldTagRange(int field_tag) {
1088 return false;
1089 }
1090 public const int ReadsFieldTag=9;
1091 public int ReadsCount { get { return super.ReadsCount;} }
1092 public bool HasReads(int index) {return true;}
1093 public StorageElement Reads(int index) {
1094 return new StorageElement(super.GetReads(index));
1095 }
1096 public const int WritesFieldTag=10;
1097 public int WritesCount { get { return super.WritesCount;} }
1098 public bool HasWrites(int index) {return true;}
1099 public StorageElement Writes(int index) {
1100 return new StorageElement(super.GetWrites(index));
1101 }
1102 public const int OptionsFieldTag=14;
1103 public bool HasOptions { get {
1104 if (!super.HasOptions) return false;
1105 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1106 } }
1107 public ulong Options{ get {
1108 if (HasOptions) {
1109 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1110 } else {
1111 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1112 }
1113 }
1114 }
1115 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1116 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1117 public static Builder CreateBuilder() { return new Builder(); }
1118 public static Builder CreateBuilder(ReadWriteSet prototype) {
1119 return (Builder)new Builder().MergeFrom(prototype);
1120 }
1121 public static ReadWriteSet ParseFrom(pb::ByteString data) {
1122 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1123 }
1124 public static ReadWriteSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1125 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1126 }
1127 public static ReadWriteSet ParseFrom(byte[] data) {
1128 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1129 }
1130 public static ReadWriteSet ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1131 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1132 }
1133 public static ReadWriteSet ParseFrom(global::System.IO.Stream data) {
1134 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1135 }
1136 public static ReadWriteSet ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1137 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1138 }
1139 public static ReadWriteSet ParseFrom(pb::CodedInputStream data) {
1140 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data));
1141 }
1142 public static ReadWriteSet ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1143 return new ReadWriteSet(_PBJ_Internal.ReadWriteSet.ParseFrom(data,er));
1144 }
1145 protected override bool _HasAllPBJFields{ get {
1146 return true
1147 ;
1148 } }
1149 public bool IsInitialized { get {
1150 return super.IsInitialized&&_HasAllPBJFields;
1151 } }
1152 public class Builder : global::PBJ.IMessage.IBuilder{
1153 protected override bool _HasAllPBJFields{ get {
1154 return true
1155 ;
1156 } }
1157 public bool IsInitialized { get {
1158 return super.IsInitialized&&_HasAllPBJFields;
1159 } }
1160 protected _PBJ_Internal.ReadWriteSet.Builder super;
1161 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1162 public _PBJ_Internal.ReadWriteSet.Builder _PBJSuper{ get { return super;} }
1163 public Builder() {super = new _PBJ_Internal.ReadWriteSet.Builder();}
1164 public Builder(_PBJ_Internal.ReadWriteSet.Builder other) {
1165 super=other;
1166 }
1167 public Builder Clone() {return new Builder(super.Clone());}
1168 public Builder MergeFrom(ReadWriteSet prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1169 public Builder Clear() {super.Clear();return this;}
1170 public ReadWriteSet BuildPartial() {return new ReadWriteSet(super.BuildPartial());}
1171 public ReadWriteSet Build() {if (_HasAllPBJFields) return new ReadWriteSet(super.Build());return null;}
1172 public pbd::MessageDescriptor DescriptorForType {
1173 get { return ReadWriteSet.Descriptor; } }
1174 public Builder ClearReads() { super.ClearReads();return this;}
1175 public Builder SetReads(int index,StorageElement value) {
1176 super.SetReads(index,value._PBJSuper);
1177 return this;
1178 }
1179 public const int ReadsFieldTag=9;
1180 public int ReadsCount { get { return super.ReadsCount;} }
1181 public bool HasReads(int index) {return true;}
1182 public StorageElement Reads(int index) {
1183 return new StorageElement(super.GetReads(index));
1184 }
1185 public Builder AddReads(StorageElement value) {
1186 super.AddReads(value._PBJSuper);
1187 return this;
1188 }
1189 public Builder ClearWrites() { super.ClearWrites();return this;}
1190 public Builder SetWrites(int index,StorageElement value) {
1191 super.SetWrites(index,value._PBJSuper);
1192 return this;
1193 }
1194 public const int WritesFieldTag=10;
1195 public int WritesCount { get { return super.WritesCount;} }
1196 public bool HasWrites(int index) {return true;}
1197 public StorageElement Writes(int index) {
1198 return new StorageElement(super.GetWrites(index));
1199 }
1200 public Builder AddWrites(StorageElement value) {
1201 super.AddWrites(value._PBJSuper);
1202 return this;
1203 }
1204 public Builder ClearOptions() { super.ClearOptions();return this;}
1205 public const int OptionsFieldTag=14;
1206 public bool HasOptions { get {
1207 if (!super.HasOptions) return false;
1208 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1209 } }
1210 public ulong Options{ get {
1211 if (HasOptions) {
1212 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1213 } else {
1214 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.ReadWriteSetOptions.RETURN_READ_NAMES);
1215 }
1216 }
1217 set {
1218 super.Options=((value));
1219 }
1220 }
1221 }
1222 }
1223}
1224namespace Sirikata.Persistence.Protocol {
1225 public class Minitransaction : PBJ.IMessage {
1226 protected _PBJ_Internal.Minitransaction super;
1227 public _PBJ_Internal.Minitransaction _PBJSuper{ get { return super;} }
1228 public Minitransaction() {
1229 super=new _PBJ_Internal.Minitransaction();
1230 }
1231 public Minitransaction(_PBJ_Internal.Minitransaction reference) {
1232 super=reference;
1233 }
1234 public static Minitransaction defaultInstance= new Minitransaction (_PBJ_Internal.Minitransaction.DefaultInstance);
1235 public static Minitransaction DefaultInstance{
1236 get {return defaultInstance;}
1237 }
1238 public static pbd.MessageDescriptor Descriptor {
1239 get { return _PBJ_Internal.Minitransaction.Descriptor; } }
1240 public static class Types {
1241 public enum TransactionOptions {
1242 RETURN_READ_NAMES=_PBJ_Internal.Minitransaction.Types.TransactionOptions.RETURN_READ_NAMES
1243 };
1244 }
1245 public static bool WithinReservedFieldTagRange(int field_tag) {
1246 return false;
1247 }
1248 public static bool WithinExtensionFieldTagRange(int field_tag) {
1249 return false;
1250 }
1251 public const int ReadsFieldTag=9;
1252 public int ReadsCount { get { return super.ReadsCount;} }
1253 public bool HasReads(int index) {return true;}
1254 public StorageElement Reads(int index) {
1255 return new StorageElement(super.GetReads(index));
1256 }
1257 public const int WritesFieldTag=10;
1258 public int WritesCount { get { return super.WritesCount;} }
1259 public bool HasWrites(int index) {return true;}
1260 public StorageElement Writes(int index) {
1261 return new StorageElement(super.GetWrites(index));
1262 }
1263 public const int ComparesFieldTag=11;
1264 public int ComparesCount { get { return super.ComparesCount;} }
1265 public bool HasCompares(int index) {return true;}
1266 public CompareElement Compares(int index) {
1267 return new CompareElement(super.GetCompares(index));
1268 }
1269 public const int OptionsFieldTag=14;
1270 public bool HasOptions { get {
1271 if (!super.HasOptions) return false;
1272 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1273 } }
1274 public ulong Options{ get {
1275 if (HasOptions) {
1276 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1277 } else {
1278 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1279 }
1280 }
1281 }
1282 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1283 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1284 public static Builder CreateBuilder() { return new Builder(); }
1285 public static Builder CreateBuilder(Minitransaction prototype) {
1286 return (Builder)new Builder().MergeFrom(prototype);
1287 }
1288 public static Minitransaction ParseFrom(pb::ByteString data) {
1289 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1290 }
1291 public static Minitransaction ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1292 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1293 }
1294 public static Minitransaction ParseFrom(byte[] data) {
1295 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1296 }
1297 public static Minitransaction ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1298 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1299 }
1300 public static Minitransaction ParseFrom(global::System.IO.Stream data) {
1301 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1302 }
1303 public static Minitransaction ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1304 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1305 }
1306 public static Minitransaction ParseFrom(pb::CodedInputStream data) {
1307 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data));
1308 }
1309 public static Minitransaction ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1310 return new Minitransaction(_PBJ_Internal.Minitransaction.ParseFrom(data,er));
1311 }
1312 protected override bool _HasAllPBJFields{ get {
1313 return true
1314 ;
1315 } }
1316 public bool IsInitialized { get {
1317 return super.IsInitialized&&_HasAllPBJFields;
1318 } }
1319 public class Builder : global::PBJ.IMessage.IBuilder{
1320 protected override bool _HasAllPBJFields{ get {
1321 return true
1322 ;
1323 } }
1324 public bool IsInitialized { get {
1325 return super.IsInitialized&&_HasAllPBJFields;
1326 } }
1327 protected _PBJ_Internal.Minitransaction.Builder super;
1328 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1329 public _PBJ_Internal.Minitransaction.Builder _PBJSuper{ get { return super;} }
1330 public Builder() {super = new _PBJ_Internal.Minitransaction.Builder();}
1331 public Builder(_PBJ_Internal.Minitransaction.Builder other) {
1332 super=other;
1333 }
1334 public Builder Clone() {return new Builder(super.Clone());}
1335 public Builder MergeFrom(Minitransaction prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1336 public Builder Clear() {super.Clear();return this;}
1337 public Minitransaction BuildPartial() {return new Minitransaction(super.BuildPartial());}
1338 public Minitransaction Build() {if (_HasAllPBJFields) return new Minitransaction(super.Build());return null;}
1339 public pbd::MessageDescriptor DescriptorForType {
1340 get { return Minitransaction.Descriptor; } }
1341 public Builder ClearReads() { super.ClearReads();return this;}
1342 public Builder SetReads(int index,StorageElement value) {
1343 super.SetReads(index,value._PBJSuper);
1344 return this;
1345 }
1346 public const int ReadsFieldTag=9;
1347 public int ReadsCount { get { return super.ReadsCount;} }
1348 public bool HasReads(int index) {return true;}
1349 public StorageElement Reads(int index) {
1350 return new StorageElement(super.GetReads(index));
1351 }
1352 public Builder AddReads(StorageElement value) {
1353 super.AddReads(value._PBJSuper);
1354 return this;
1355 }
1356 public Builder ClearWrites() { super.ClearWrites();return this;}
1357 public Builder SetWrites(int index,StorageElement value) {
1358 super.SetWrites(index,value._PBJSuper);
1359 return this;
1360 }
1361 public const int WritesFieldTag=10;
1362 public int WritesCount { get { return super.WritesCount;} }
1363 public bool HasWrites(int index) {return true;}
1364 public StorageElement Writes(int index) {
1365 return new StorageElement(super.GetWrites(index));
1366 }
1367 public Builder AddWrites(StorageElement value) {
1368 super.AddWrites(value._PBJSuper);
1369 return this;
1370 }
1371 public Builder ClearCompares() { super.ClearCompares();return this;}
1372 public Builder SetCompares(int index,CompareElement value) {
1373 super.SetCompares(index,value._PBJSuper);
1374 return this;
1375 }
1376 public const int ComparesFieldTag=11;
1377 public int ComparesCount { get { return super.ComparesCount;} }
1378 public bool HasCompares(int index) {return true;}
1379 public CompareElement Compares(int index) {
1380 return new CompareElement(super.GetCompares(index));
1381 }
1382 public Builder AddCompares(CompareElement value) {
1383 super.AddCompares(value._PBJSuper);
1384 return this;
1385 }
1386 public Builder ClearOptions() { super.ClearOptions();return this;}
1387 public const int OptionsFieldTag=14;
1388 public bool HasOptions { get {
1389 if (!super.HasOptions) return false;
1390 return PBJ._PBJ.ValidateFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1391 } }
1392 public ulong Options{ get {
1393 if (HasOptions) {
1394 return (ulong)PBJ._PBJ.CastFlags(super.Options,(ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1395 } else {
1396 return (ulong)PBJ._PBJ.CastFlags((ulong)Types.TransactionOptions.RETURN_READ_NAMES);
1397 }
1398 }
1399 set {
1400 super.Options=((value));
1401 }
1402 }
1403 }
1404 }
1405}
1406namespace Sirikata.Persistence.Protocol {
1407 public class Response : PBJ.IMessage {
1408 protected _PBJ_Internal.Response super;
1409 public _PBJ_Internal.Response _PBJSuper{ get { return super;} }
1410 public Response() {
1411 super=new _PBJ_Internal.Response();
1412 }
1413 public Response(_PBJ_Internal.Response reference) {
1414 super=reference;
1415 }
1416 public static Response defaultInstance= new Response (_PBJ_Internal.Response.DefaultInstance);
1417 public static Response DefaultInstance{
1418 get {return defaultInstance;}
1419 }
1420 public static pbd.MessageDescriptor Descriptor {
1421 get { return _PBJ_Internal.Response.Descriptor; } }
1422 public static class Types {
1423 public enum ReturnStatus {
1424 SUCCESS=_PBJ_Internal.Response.Types.ReturnStatus.SUCCESS,
1425 DATABASE_LOCKED=_PBJ_Internal.Response.Types.ReturnStatus.DATABASE_LOCKED,
1426 KEY_MISSING=_PBJ_Internal.Response.Types.ReturnStatus.KEY_MISSING,
1427 COMPARISON_FAILED=_PBJ_Internal.Response.Types.ReturnStatus.COMPARISON_FAILED,
1428 INTERNAL_ERROR=_PBJ_Internal.Response.Types.ReturnStatus.INTERNAL_ERROR
1429 };
1430 }
1431 public static bool WithinReservedFieldTagRange(int field_tag) {
1432 return false||(field_tag>=1&&field_tag<=8);
1433 }
1434 public static bool WithinExtensionFieldTagRange(int field_tag) {
1435 return false;
1436 }
1437 public const int ReadsFieldTag=9;
1438 public int ReadsCount { get { return super.ReadsCount;} }
1439 public bool HasReads(int index) {return true;}
1440 public StorageElement Reads(int index) {
1441 return new StorageElement(super.GetReads(index));
1442 }
1443 public const int ReturnStatusFieldTag=15;
1444 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
1445 public Types.ReturnStatus ReturnStatus{ get {
1446 if (HasReturnStatus) {
1447 return (Types.ReturnStatus)super.ReturnStatus;
1448 } else {
1449 return new Types.ReturnStatus();
1450 }
1451 }
1452 }
1453 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1454 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1455 public static Builder CreateBuilder() { return new Builder(); }
1456 public static Builder CreateBuilder(Response prototype) {
1457 return (Builder)new Builder().MergeFrom(prototype);
1458 }
1459 public static Response ParseFrom(pb::ByteString data) {
1460 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1461 }
1462 public static Response ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1463 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1464 }
1465 public static Response ParseFrom(byte[] data) {
1466 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1467 }
1468 public static Response ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1469 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1470 }
1471 public static Response ParseFrom(global::System.IO.Stream data) {
1472 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1473 }
1474 public static Response ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1475 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1476 }
1477 public static Response ParseFrom(pb::CodedInputStream data) {
1478 return new Response(_PBJ_Internal.Response.ParseFrom(data));
1479 }
1480 public static Response ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1481 return new Response(_PBJ_Internal.Response.ParseFrom(data,er));
1482 }
1483 protected override bool _HasAllPBJFields{ get {
1484 return true
1485 ;
1486 } }
1487 public bool IsInitialized { get {
1488 return super.IsInitialized&&_HasAllPBJFields;
1489 } }
1490 public class Builder : global::PBJ.IMessage.IBuilder{
1491 protected override bool _HasAllPBJFields{ get {
1492 return true
1493 ;
1494 } }
1495 public bool IsInitialized { get {
1496 return super.IsInitialized&&_HasAllPBJFields;
1497 } }
1498 protected _PBJ_Internal.Response.Builder super;
1499 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1500 public _PBJ_Internal.Response.Builder _PBJSuper{ get { return super;} }
1501 public Builder() {super = new _PBJ_Internal.Response.Builder();}
1502 public Builder(_PBJ_Internal.Response.Builder other) {
1503 super=other;
1504 }
1505 public Builder Clone() {return new Builder(super.Clone());}
1506 public Builder MergeFrom(Response prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1507 public Builder Clear() {super.Clear();return this;}
1508 public Response BuildPartial() {return new Response(super.BuildPartial());}
1509 public Response Build() {if (_HasAllPBJFields) return new Response(super.Build());return null;}
1510 public pbd::MessageDescriptor DescriptorForType {
1511 get { return Response.Descriptor; } }
1512 public Builder ClearReads() { super.ClearReads();return this;}
1513 public Builder SetReads(int index,StorageElement value) {
1514 super.SetReads(index,value._PBJSuper);
1515 return this;
1516 }
1517 public const int ReadsFieldTag=9;
1518 public int ReadsCount { get { return super.ReadsCount;} }
1519 public bool HasReads(int index) {return true;}
1520 public StorageElement Reads(int index) {
1521 return new StorageElement(super.GetReads(index));
1522 }
1523 public Builder AddReads(StorageElement value) {
1524 super.AddReads(value._PBJSuper);
1525 return this;
1526 }
1527 public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;}
1528 public const int ReturnStatusFieldTag=15;
1529 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
1530 public Types.ReturnStatus ReturnStatus{ get {
1531 if (HasReturnStatus) {
1532 return (Types.ReturnStatus)super.ReturnStatus;
1533 } else {
1534 return new Types.ReturnStatus();
1535 }
1536 }
1537 set {
1538 super.ReturnStatus=((_PBJ_Internal.Response.Types.ReturnStatus)value);
1539 }
1540 }
1541 }
1542 }
1543}
generated by cgit v1.1 at 2024-10-31 05:01:48 +0000