示例#1
0
 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_
示例#2
0
 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_
示例#3
0
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 = """"""
示例#4
0
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 = """"""