class TransactionRequest(ProtocolBuffer.ProtocolMessage):
has_puts_ = 0
puts_ = None
has_deletes_ = 0
deletes_ = None
def __init__(self, contents=None):
self.precondition_ = []
self.lazy_init_lock_ = thread.allocate_lock()
if contents is not None: self.MergeFromString(contents)
def precondition_size(self):
return len(self.precondition_)
def precondition_list(self):
return self.precondition_
def precondition(self, i):
return self.precondition_[i]
def mutable_precondition(self, i):
return self.precondition_[i]
def add_precondition(self):
x = TransactionRequest_Precondition()
self.precondition_.append(x)
return x
def clear_precondition(self):
self.precondition_ = []
def puts(self):
if self.puts_ is None:
self.lazy_init_lock_.acquire()
try:
if self.puts_ is None: self.puts_ = PutRequest()
finally:
self.lazy_init_lock_.release()
return self.puts_
def mutable_puts(self):
self.has_puts_ = 1
return self.puts()
def clear_puts(self):
if self.has_puts_:
self.has_puts_ = 0
if self.puts_ is not None: self.puts_.Clear()
def has_puts(self):
return self.has_puts_
def deletes(self):
if self.deletes_ is None:
self.lazy_init_lock_.acquire()
try:
if self.deletes_ is None: self.deletes_ = DeleteRequest()
finally:
self.lazy_init_lock_.release()
return self.deletes_
def mutable_deletes(self):
self.has_deletes_ = 1
return self.deletes()
def clear_deletes(self):
if self.has_deletes_:
self.has_deletes_ = 0
if self.deletes_ is not None: self.deletes_.Clear()
def has_deletes(self):
return self.has_deletes_
def MergeFrom(self, x):
assert x is not self
for i in xrange(x.precondition_size()):
self.add_precondition().CopyFrom(x.precondition(i))
if (x.has_puts()): self.mutable_puts().MergeFrom(x.puts())
if (x.has_deletes()): self.mutable_deletes().MergeFrom(x.deletes())
def Equals(self, x):
if x is self: return 1
if len(self.precondition_) != len(x.precondition_): return 0
for e1, e2 in zip(self.precondition_, x.precondition_):
if e1 != e2: return 0
if self.has_puts_ != x.has_puts_: return 0
if self.has_puts_ and self.puts_ != x.puts_: return 0
if self.has_deletes_ != x.has_deletes_: return 0
if self.has_deletes_ and self.deletes_ != x.deletes_: return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
for p in self.precondition_:
if not p.IsInitialized(debug_strs): initialized = 0
if (self.has_puts_ and not self.puts_.IsInitialized(debug_strs)):
initialized = 0
if (self.has_deletes_ and not self.deletes_.IsInitialized(debug_strs)):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += 2 * len(self.precondition_)
for i in xrange(len(self.precondition_)):
n += self.precondition_[i].ByteSize()
if (self.has_puts_): n += 1 + self.lengthString(self.puts_.ByteSize())
if (self.has_deletes_):
n += 1 + self.lengthString(self.deletes_.ByteSize())
return n
def ByteSizePartial(self):
n = 0
n += 2 * len(self.precondition_)
for i in xrange(len(self.precondition_)):
n += self.precondition_[i].ByteSizePartial()
if (self.has_puts_):
n += 1 + self.lengthString(self.puts_.ByteSizePartial())
if (self.has_deletes_):
n += 1 + self.lengthString(self.deletes_.ByteSizePartial())
return n
def Clear(self):
self.clear_precondition()
self.clear_puts()
self.clear_deletes()
def OutputUnchecked(self, out):
for i in xrange(len(self.precondition_)):
out.putVarInt32(11)
self.precondition_[i].OutputUnchecked(out)
out.putVarInt32(12)
if (self.has_puts_):
out.putVarInt32(34)
out.putVarInt32(self.puts_.ByteSize())
self.puts_.OutputUnchecked(out)
if (self.has_deletes_):
out.putVarInt32(42)
out.putVarInt32(self.deletes_.ByteSize())
self.deletes_.OutputUnchecked(out)
def OutputPartial(self, out):
for i in xrange(len(self.precondition_)):
out.putVarInt32(11)
self.precondition_[i].OutputPartial(out)
out.putVarInt32(12)
if (self.has_puts_):
out.putVarInt32(34)
out.putVarInt32(self.puts_.ByteSizePartial())
self.puts_.OutputPartial(out)
if (self.has_deletes_):
out.putVarInt32(42)
out.putVarInt32(self.deletes_.ByteSizePartial())
self.deletes_.OutputPartial(out)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 11:
self.add_precondition().TryMerge(d)
continue
if tt == 34:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
d.pos() + length)
d.skip(length)
self.mutable_puts().TryMerge(tmp)
continue
if tt == 42:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
d.pos() + length)
d.skip(length)
self.mutable_deletes().TryMerge(tmp)
continue
if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
cnt = 0
for e in self.precondition_:
elm = ""
if printElemNumber: elm = "(%d)" % cnt
res += prefix + ("Precondition%s {\n" % elm)
res += e.__str__(prefix + " ", printElemNumber)
res += prefix + "}\n"
cnt += 1
if self.has_puts_:
res += prefix + "puts <\n"
res += self.puts_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_deletes_:
res += prefix + "deletes <\n"
res += self.deletes_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in xrange(0, 1 + maxtag)])
kPreconditionGroup = 1
kPreconditionkey = 2
kPreconditionhash = 3
kputs = 4
kdeletes = 5
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "Precondition",
2: "key",
3: "hash",
4: "puts",
5: "deletes",
}, 5)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STARTGROUP,
2: ProtocolBuffer.Encoder.STRING,
3: ProtocolBuffer.Encoder.STRING,
4: ProtocolBuffer.Encoder.STRING,
5: ProtocolBuffer.Encoder.STRING,
}, 5, ProtocolBuffer.Encoder.MAX_TYPE)
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
