diff options
author | Jonathan Freedman | 2010-10-05 20:06:27 -0400 |
---|---|---|
committer | Jonathan Freedman | 2010-10-05 20:06:27 -0400 |
commit | 84cf0ffbf1a7a82caf39d0e19607b0030fb668de (patch) | |
tree | 4c4a66541dfe10c6d6b1bcfbaa9a52ca5b54898e /OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs | |
parent | Merge branch 'master' of git://opensimulator.org/git/opensim (diff) | |
parent | Remove sirikata project (diff) | |
download | opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.zip opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.tar.gz opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.tar.bz2 opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.tar.xz |
Merge branch 'master' of git://opensimulator.org/git/opensim
Diffstat (limited to 'OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs')
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/Persistence.pbj.cs | 1543 |
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 | |||
28 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
29 | using pb = global::Google.ProtocolBuffers; | ||
30 | namespace 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 | } | ||
188 | namespace 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 | } | ||
298 | namespace 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 | } | ||
532 | namespace 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 | } | ||
742 | namespace 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 | } | ||
849 | namespace 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 | } | ||
956 | namespace 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 | } | ||
1063 | namespace 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 | } | ||
1224 | namespace 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 | } | ||
1406 | namespace 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 | } | ||