Пример #1
0
 def exception(self):
     if self.exception_ is None:
         self.lazy_init_lock_.acquire()
         try:
             if self.exception_ is None: self.exception_ = RawMessage()
         finally:
             self.lazy_init_lock_.release()
     return self.exception_
Пример #2
0
 def response(self):
     if self.response_ is None:
         self.lazy_init_lock_.acquire()
         try:
             if self.response_ is None: self.response_ = RawMessage()
         finally:
             self.lazy_init_lock_.release()
     return self.response_
Пример #3
0
 def response(self):
   if self.response_ is None:
     self.lazy_init_lock_.acquire()
     try:
       if self.response_ is None: self.response_ = RawMessage()
     finally:
       self.lazy_init_lock_.release()
   return self.response_
Пример #4
0
 def java_exception(self):
   if self.java_exception_ is None:
     self.lazy_init_lock_.acquire()
     try:
       if self.java_exception_ is None: self.java_exception_ = RawMessage()
     finally:
       self.lazy_init_lock_.release()
   return self.java_exception_
Пример #5
0
 def __init__(self, contents=None):
     self.request_ = RawMessage()
     if contents is not None: self.MergeFromString(contents)
Пример #6
0
class Response(ProtocolBuffer.ProtocolMessage):
    has_response_ = 0
    response_ = None
    has_exception_ = 0
    exception_ = None
    has_application_error_ = 0
    application_error_ = None
    has_java_exception_ = 0
    java_exception_ = None

    def __init__(self, contents=None):
        self.lazy_init_lock_ = thread.allocate_lock()
        if contents is not None: self.MergeFromString(contents)

    def response(self):
        if self.response_ is None:
            self.lazy_init_lock_.acquire()
            try:
                if self.response_ is None: self.response_ = RawMessage()
            finally:
                self.lazy_init_lock_.release()
        return self.response_

    def mutable_response(self):
        self.has_response_ = 1
        return self.response()

    def clear_response(self):
        if self.has_response_:
            self.has_response_ = 0
            if self.response_ is not None: self.response_.Clear()

    def has_response(self):
        return self.has_response_

    def exception(self):
        if self.exception_ is None:
            self.lazy_init_lock_.acquire()
            try:
                if self.exception_ is None: self.exception_ = RawMessage()
            finally:
                self.lazy_init_lock_.release()
        return self.exception_

    def mutable_exception(self):
        self.has_exception_ = 1
        return self.exception()

    def clear_exception(self):
        if self.has_exception_:
            self.has_exception_ = 0
            if self.exception_ is not None: self.exception_.Clear()

    def has_exception(self):
        return self.has_exception_

    def application_error(self):
        if self.application_error_ is None:
            self.lazy_init_lock_.acquire()
            try:
                if self.application_error_ is None:
                    self.application_error_ = ApplicationError()
            finally:
                self.lazy_init_lock_.release()
        return self.application_error_

    def mutable_application_error(self):
        self.has_application_error_ = 1
        return self.application_error()

    def clear_application_error(self):
        if self.has_application_error_:
            self.has_application_error_ = 0
            if self.application_error_ is not None:
                self.application_error_.Clear()

    def has_application_error(self):
        return self.has_application_error_

    def java_exception(self):
        if self.java_exception_ is None:
            self.lazy_init_lock_.acquire()
            try:
                if self.java_exception_ is None:
                    self.java_exception_ = RawMessage()
            finally:
                self.lazy_init_lock_.release()
        return self.java_exception_

    def mutable_java_exception(self):
        self.has_java_exception_ = 1
        return self.java_exception()

    def clear_java_exception(self):
        if self.has_java_exception_:
            self.has_java_exception_ = 0
            if self.java_exception_ is not None: self.java_exception_.Clear()

    def has_java_exception(self):
        return self.has_java_exception_

    def MergeFrom(self, x):
        assert x is not self
        if (x.has_response()): self.mutable_response().MergeFrom(x.response())
        if (x.has_exception()):
            self.mutable_exception().MergeFrom(x.exception())
        if (x.has_application_error()):
            self.mutable_application_error().MergeFrom(x.application_error())
        if (x.has_java_exception()):
            self.mutable_java_exception().MergeFrom(x.java_exception())

    def Equals(self, x):
        if x is self: return 1
        if self.has_response_ != x.has_response_: return 0
        if self.has_response_ and self.response_ != x.response_: return 0
        if self.has_exception_ != x.has_exception_: return 0
        if self.has_exception_ and self.exception_ != x.exception_: return 0
        if self.has_application_error_ != x.has_application_error_: return 0
        if self.has_application_error_ and self.application_error_ != x.application_error_:
            return 0
        if self.has_java_exception_ != x.has_java_exception_: return 0
        if self.has_java_exception_ and self.java_exception_ != x.java_exception_:
            return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if (self.has_response_
                and not self.response_.IsInitialized(debug_strs)):
            initialized = 0
        if (self.has_exception_
                and not self.exception_.IsInitialized(debug_strs)):
            initialized = 0
        if (self.has_application_error_
                and not self.application_error_.IsInitialized(debug_strs)):
            initialized = 0
        if (self.has_java_exception_
                and not self.java_exception_.IsInitialized(debug_strs)):
            initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        if (self.has_response_):
            n += 1 + self.lengthString(self.response_.ByteSize())
        if (self.has_exception_):
            n += 1 + self.lengthString(self.exception_.ByteSize())
        if (self.has_application_error_):
            n += 1 + self.lengthString(self.application_error_.ByteSize())
        if (self.has_java_exception_):
            n += 1 + self.lengthString(self.java_exception_.ByteSize())
        return n

    def ByteSizePartial(self):
        n = 0
        if (self.has_response_):
            n += 1 + self.lengthString(self.response_.ByteSizePartial())
        if (self.has_exception_):
            n += 1 + self.lengthString(self.exception_.ByteSizePartial())
        if (self.has_application_error_):
            n += 1 + self.lengthString(
                self.application_error_.ByteSizePartial())
        if (self.has_java_exception_):
            n += 1 + self.lengthString(self.java_exception_.ByteSizePartial())
        return n

    def Clear(self):
        self.clear_response()
        self.clear_exception()
        self.clear_application_error()
        self.clear_java_exception()

    def OutputUnchecked(self, out):
        if (self.has_response_):
            out.putVarInt32(10)
            out.putVarInt32(self.response_.ByteSize())
            self.response_.OutputUnchecked(out)
        if (self.has_exception_):
            out.putVarInt32(18)
            out.putVarInt32(self.exception_.ByteSize())
            self.exception_.OutputUnchecked(out)
        if (self.has_application_error_):
            out.putVarInt32(26)
            out.putVarInt32(self.application_error_.ByteSize())
            self.application_error_.OutputUnchecked(out)
        if (self.has_java_exception_):
            out.putVarInt32(34)
            out.putVarInt32(self.java_exception_.ByteSize())
            self.java_exception_.OutputUnchecked(out)

    def OutputPartial(self, out):
        if (self.has_response_):
            out.putVarInt32(10)
            out.putVarInt32(self.response_.ByteSizePartial())
            self.response_.OutputPartial(out)
        if (self.has_exception_):
            out.putVarInt32(18)
            out.putVarInt32(self.exception_.ByteSizePartial())
            self.exception_.OutputPartial(out)
        if (self.has_application_error_):
            out.putVarInt32(26)
            out.putVarInt32(self.application_error_.ByteSizePartial())
            self.application_error_.OutputPartial(out)
        if (self.has_java_exception_):
            out.putVarInt32(34)
            out.putVarInt32(self.java_exception_.ByteSizePartial())
            self.java_exception_.OutputPartial(out)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
                                             d.pos() + length)
                d.skip(length)
                self.mutable_response().TryMerge(tmp)
                continue
            if tt == 18:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
                                             d.pos() + length)
                d.skip(length)
                self.mutable_exception().TryMerge(tmp)
                continue
            if tt == 26:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
                                             d.pos() + length)
                d.skip(length)
                self.mutable_application_error().TryMerge(tmp)
                continue
            if tt == 34:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
                                             d.pos() + length)
                d.skip(length)
                self.mutable_java_exception().TryMerge(tmp)
                continue
            if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_response_:
            res += prefix + "response <\n"
            res += self.response_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_exception_:
            res += prefix + "exception <\n"
            res += self.exception_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_application_error_:
            res += prefix + "application_error <\n"
            res += self.application_error_.__str__(prefix + "  ",
                                                   printElemNumber)
            res += prefix + ">\n"
        if self.has_java_exception_:
            res += prefix + "java_exception <\n"
            res += self.java_exception_.__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)])

    kresponse = 1
    kexception = 2
    kapplication_error = 3
    kjava_exception = 4

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            1: "response",
            2: "exception",
            3: "application_error",
            4: "java_exception",
        }, 4)

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            1: ProtocolBuffer.Encoder.STRING,
            2: ProtocolBuffer.Encoder.STRING,
            3: ProtocolBuffer.Encoder.STRING,
            4: ProtocolBuffer.Encoder.STRING,
        }, 4, ProtocolBuffer.Encoder.MAX_TYPE)

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
Пример #7
0
class Request(ProtocolBuffer.ProtocolMessage):
    has_service_name_ = 0
    service_name_ = ""
    has_method_ = 0
    method_ = ""
    has_request_ = 0

    def __init__(self, contents=None):
        self.request_ = RawMessage()
        if contents is not None: self.MergeFromString(contents)

    def service_name(self):
        return self.service_name_

    def set_service_name(self, x):
        self.has_service_name_ = 1
        self.service_name_ = x

    def clear_service_name(self):
        if self.has_service_name_:
            self.has_service_name_ = 0
            self.service_name_ = ""

    def has_service_name(self):
        return self.has_service_name_

    def method(self):
        return self.method_

    def set_method(self, x):
        self.has_method_ = 1
        self.method_ = x

    def clear_method(self):
        if self.has_method_:
            self.has_method_ = 0
            self.method_ = ""

    def has_method(self):
        return self.has_method_

    def request(self):
        return self.request_

    def mutable_request(self):
        self.has_request_ = 1
        return self.request_

    def clear_request(self):
        self.has_request_ = 0
        self.request_.Clear()

    def has_request(self):
        return self.has_request_

    def MergeFrom(self, x):
        assert x is not self
        if (x.has_service_name()): self.set_service_name(x.service_name())
        if (x.has_method()): self.set_method(x.method())
        if (x.has_request()): self.mutable_request().MergeFrom(x.request())

    def Equals(self, x):
        if x is self: return 1
        if self.has_service_name_ != x.has_service_name_: return 0
        if self.has_service_name_ and self.service_name_ != x.service_name_:
            return 0
        if self.has_method_ != x.has_method_: return 0
        if self.has_method_ and self.method_ != x.method_: return 0
        if self.has_request_ != x.has_request_: return 0
        if self.has_request_ and self.request_ != x.request_: return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if (not self.has_service_name_):
            initialized = 0
            if debug_strs is not None:
                debug_strs.append('Required field: service_name not set.')
        if (not self.has_method_):
            initialized = 0
            if debug_strs is not None:
                debug_strs.append('Required field: method not set.')
        if (not self.has_request_):
            initialized = 0
            if debug_strs is not None:
                debug_strs.append('Required field: request not set.')
        elif not self.request_.IsInitialized(debug_strs):
            initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        n += self.lengthString(len(self.service_name_))
        n += self.lengthString(len(self.method_))
        n += self.lengthString(self.request_.ByteSize())
        return n + 3

    def ByteSizePartial(self):
        n = 0
        if (self.has_service_name_):
            n += 1
            n += self.lengthString(len(self.service_name_))
        if (self.has_method_):
            n += 1
            n += self.lengthString(len(self.method_))
        if (self.has_request_):
            n += 1
            n += self.lengthString(self.request_.ByteSizePartial())
        return n

    def Clear(self):
        self.clear_service_name()
        self.clear_method()
        self.clear_request()

    def OutputUnchecked(self, out):
        out.putVarInt32(18)
        out.putPrefixedString(self.service_name_)
        out.putVarInt32(26)
        out.putPrefixedString(self.method_)
        out.putVarInt32(34)
        out.putVarInt32(self.request_.ByteSize())
        self.request_.OutputUnchecked(out)

    def OutputPartial(self, out):
        if (self.has_service_name_):
            out.putVarInt32(18)
            out.putPrefixedString(self.service_name_)
        if (self.has_method_):
            out.putVarInt32(26)
            out.putPrefixedString(self.method_)
        if (self.has_request_):
            out.putVarInt32(34)
            out.putVarInt32(self.request_.ByteSizePartial())
            self.request_.OutputPartial(out)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 18:
                self.set_service_name(d.getPrefixedString())
                continue
            if tt == 26:
                self.set_method(d.getPrefixedString())
                continue
            if tt == 34:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
                                             d.pos() + length)
                d.skip(length)
                self.mutable_request().TryMerge(tmp)
                continue
            if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_service_name_:
            res += prefix + ("service_name: %s\n" %
                             self.DebugFormatString(self.service_name_))
        if self.has_method_:
            res += prefix + ("method: %s\n" %
                             self.DebugFormatString(self.method_))
        if self.has_request_:
            res += prefix + "request <\n"
            res += self.request_.__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)])

    kservice_name = 2
    kmethod = 3
    krequest = 4

    _TEXT = _BuildTagLookupTable(
        {
            0: "ErrorCode",
            2: "service_name",
            3: "method",
            4: "request",
        }, 4)

    _TYPES = _BuildTagLookupTable(
        {
            0: ProtocolBuffer.Encoder.NUMERIC,
            2: ProtocolBuffer.Encoder.STRING,
            3: ProtocolBuffer.Encoder.STRING,
            4: ProtocolBuffer.Encoder.STRING,
        }, 4, ProtocolBuffer.Encoder.MAX_TYPE)

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
Пример #8
0
 def __init__(self, contents=None):
   self.request_ = RawMessage()
   if contents is not None: self.MergeFromString(contents)
Пример #9
0
class Response(ProtocolBuffer.ProtocolMessage):
  has_response_ = 0
  response_ = None
  has_exception_ = 0
  exception_ = None
  has_application_error_ = 0
  application_error_ = None
  has_java_exception_ = 0
  java_exception_ = None

  def __init__(self, contents=None):
    self.lazy_init_lock_ = thread.allocate_lock()
    if contents is not None: self.MergeFromString(contents)

  def response(self):
    if self.response_ is None:
      self.lazy_init_lock_.acquire()
      try:
        if self.response_ is None: self.response_ = RawMessage()
      finally:
        self.lazy_init_lock_.release()
    return self.response_

  def mutable_response(self): self.has_response_ = 1; return self.response()

  def clear_response(self):
    if self.has_response_:
      self.has_response_ = 0;
      if self.response_ is not None: self.response_.Clear()

  def has_response(self): return self.has_response_

  def exception(self):
    if self.exception_ is None:
      self.lazy_init_lock_.acquire()
      try:
        if self.exception_ is None: self.exception_ = RawMessage()
      finally:
        self.lazy_init_lock_.release()
    return self.exception_

  def mutable_exception(self): self.has_exception_ = 1; return self.exception()

  def clear_exception(self):
    if self.has_exception_:
      self.has_exception_ = 0;
      if self.exception_ is not None: self.exception_.Clear()

  def has_exception(self): return self.has_exception_

  def application_error(self):
    if self.application_error_ is None:
      self.lazy_init_lock_.acquire()
      try:
        if self.application_error_ is None: self.application_error_ = ApplicationError()
      finally:
        self.lazy_init_lock_.release()
    return self.application_error_

  def mutable_application_error(self): self.has_application_error_ = 1; return self.application_error()

  def clear_application_error(self):
    if self.has_application_error_:
      self.has_application_error_ = 0;
      if self.application_error_ is not None: self.application_error_.Clear()

  def has_application_error(self): return self.has_application_error_

  def java_exception(self):
    if self.java_exception_ is None:
      self.lazy_init_lock_.acquire()
      try:
        if self.java_exception_ is None: self.java_exception_ = RawMessage()
      finally:
        self.lazy_init_lock_.release()
    return self.java_exception_

  def mutable_java_exception(self): self.has_java_exception_ = 1; return self.java_exception()

  def clear_java_exception(self):
    if self.has_java_exception_:
      self.has_java_exception_ = 0;
      if self.java_exception_ is not None: self.java_exception_.Clear()

  def has_java_exception(self): return self.has_java_exception_


  def MergeFrom(self, x):
    assert x is not self
    if (x.has_response()): self.mutable_response().MergeFrom(x.response())
    if (x.has_exception()): self.mutable_exception().MergeFrom(x.exception())
    if (x.has_application_error()): self.mutable_application_error().MergeFrom(x.application_error())
    if (x.has_java_exception()): self.mutable_java_exception().MergeFrom(x.java_exception())

  def Equals(self, x):
    if x is self: return 1
    if self.has_response_ != x.has_response_: return 0
    if self.has_response_ and self.response_ != x.response_: return 0
    if self.has_exception_ != x.has_exception_: return 0
    if self.has_exception_ and self.exception_ != x.exception_: return 0
    if self.has_application_error_ != x.has_application_error_: return 0
    if self.has_application_error_ and self.application_error_ != x.application_error_: return 0
    if self.has_java_exception_ != x.has_java_exception_: return 0
    if self.has_java_exception_ and self.java_exception_ != x.java_exception_: return 0
    return 1

  def IsInitialized(self, debug_strs=None):
    initialized = 1
    if (self.has_response_ and not self.response_.IsInitialized(debug_strs)): initialized = 0
    if (self.has_exception_ and not self.exception_.IsInitialized(debug_strs)): initialized = 0
    if (self.has_application_error_ and not self.application_error_.IsInitialized(debug_strs)): initialized = 0
    if (self.has_java_exception_ and not self.java_exception_.IsInitialized(debug_strs)): initialized = 0
    return initialized

  def ByteSize(self):
    n = 0
    if (self.has_response_): n += 1 + self.lengthString(self.response_.ByteSize())
    if (self.has_exception_): n += 1 + self.lengthString(self.exception_.ByteSize())
    if (self.has_application_error_): n += 1 + self.lengthString(self.application_error_.ByteSize())
    if (self.has_java_exception_): n += 1 + self.lengthString(self.java_exception_.ByteSize())
    return n

  def ByteSizePartial(self):
    n = 0
    if (self.has_response_): n += 1 + self.lengthString(self.response_.ByteSizePartial())
    if (self.has_exception_): n += 1 + self.lengthString(self.exception_.ByteSizePartial())
    if (self.has_application_error_): n += 1 + self.lengthString(self.application_error_.ByteSizePartial())
    if (self.has_java_exception_): n += 1 + self.lengthString(self.java_exception_.ByteSizePartial())
    return n

  def Clear(self):
    self.clear_response()
    self.clear_exception()
    self.clear_application_error()
    self.clear_java_exception()

  def OutputUnchecked(self, out):
    if (self.has_response_):
      out.putVarInt32(10)
      out.putVarInt32(self.response_.ByteSize())
      self.response_.OutputUnchecked(out)
    if (self.has_exception_):
      out.putVarInt32(18)
      out.putVarInt32(self.exception_.ByteSize())
      self.exception_.OutputUnchecked(out)
    if (self.has_application_error_):
      out.putVarInt32(26)
      out.putVarInt32(self.application_error_.ByteSize())
      self.application_error_.OutputUnchecked(out)
    if (self.has_java_exception_):
      out.putVarInt32(34)
      out.putVarInt32(self.java_exception_.ByteSize())
      self.java_exception_.OutputUnchecked(out)

  def OutputPartial(self, out):
    if (self.has_response_):
      out.putVarInt32(10)
      out.putVarInt32(self.response_.ByteSizePartial())
      self.response_.OutputPartial(out)
    if (self.has_exception_):
      out.putVarInt32(18)
      out.putVarInt32(self.exception_.ByteSizePartial())
      self.exception_.OutputPartial(out)
    if (self.has_application_error_):
      out.putVarInt32(26)
      out.putVarInt32(self.application_error_.ByteSizePartial())
      self.application_error_.OutputPartial(out)
    if (self.has_java_exception_):
      out.putVarInt32(34)
      out.putVarInt32(self.java_exception_.ByteSizePartial())
      self.java_exception_.OutputPartial(out)

  def TryMerge(self, d):
    while d.avail() > 0:
      tt = d.getVarInt32()
      if tt == 10:
        length = d.getVarInt32()
        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
        d.skip(length)
        self.mutable_response().TryMerge(tmp)
        continue
      if tt == 18:
        length = d.getVarInt32()
        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
        d.skip(length)
        self.mutable_exception().TryMerge(tmp)
        continue
      if tt == 26:
        length = d.getVarInt32()
        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
        d.skip(length)
        self.mutable_application_error().TryMerge(tmp)
        continue
      if tt == 34:
        length = d.getVarInt32()
        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
        d.skip(length)
        self.mutable_java_exception().TryMerge(tmp)
        continue
      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
      d.skipData(tt)


  def __str__(self, prefix="", printElemNumber=0):
    res=""
    if self.has_response_:
      res+=prefix+"response <\n"
      res+=self.response_.__str__(prefix + "  ", printElemNumber)
      res+=prefix+">\n"
    if self.has_exception_:
      res+=prefix+"exception <\n"
      res+=self.exception_.__str__(prefix + "  ", printElemNumber)
      res+=prefix+">\n"
    if self.has_application_error_:
      res+=prefix+"application_error <\n"
      res+=self.application_error_.__str__(prefix + "  ", printElemNumber)
      res+=prefix+">\n"
    if self.has_java_exception_:
      res+=prefix+"java_exception <\n"
      res+=self.java_exception_.__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)])

  kresponse = 1
  kexception = 2
  kapplication_error = 3
  kjava_exception = 4

  _TEXT = _BuildTagLookupTable({
    0: "ErrorCode",
    1: "response",
    2: "exception",
    3: "application_error",
    4: "java_exception",
  }, 4)

  _TYPES = _BuildTagLookupTable({
    0: ProtocolBuffer.Encoder.NUMERIC,
    1: ProtocolBuffer.Encoder.STRING,
    2: ProtocolBuffer.Encoder.STRING,
    3: ProtocolBuffer.Encoder.STRING,
    4: ProtocolBuffer.Encoder.STRING,
  }, 4, ProtocolBuffer.Encoder.MAX_TYPE)

  _STYLE = """"""
  _STYLE_CONTENT_TYPE = """"""
Пример #10
0
class Request(ProtocolBuffer.ProtocolMessage):
  has_service_name_ = 0
  service_name_ = ""
  has_method_ = 0
  method_ = ""
  has_request_ = 0

  def __init__(self, contents=None):
    self.request_ = RawMessage()
    if contents is not None: self.MergeFromString(contents)

  def service_name(self): return self.service_name_

  def set_service_name(self, x):
    self.has_service_name_ = 1
    self.service_name_ = x

  def clear_service_name(self):
    if self.has_service_name_:
      self.has_service_name_ = 0
      self.service_name_ = ""

  def has_service_name(self): return self.has_service_name_

  def method(self): return self.method_

  def set_method(self, x):
    self.has_method_ = 1
    self.method_ = x

  def clear_method(self):
    if self.has_method_:
      self.has_method_ = 0
      self.method_ = ""

  def has_method(self): return self.has_method_

  def request(self): return self.request_

  def mutable_request(self): self.has_request_ = 1; return self.request_

  def clear_request(self):self.has_request_ = 0; self.request_.Clear()

  def has_request(self): return self.has_request_


  def MergeFrom(self, x):
    assert x is not self
    if (x.has_service_name()): self.set_service_name(x.service_name())
    if (x.has_method()): self.set_method(x.method())
    if (x.has_request()): self.mutable_request().MergeFrom(x.request())

  def Equals(self, x):
    if x is self: return 1
    if self.has_service_name_ != x.has_service_name_: return 0
    if self.has_service_name_ and self.service_name_ != x.service_name_: return 0
    if self.has_method_ != x.has_method_: return 0
    if self.has_method_ and self.method_ != x.method_: return 0
    if self.has_request_ != x.has_request_: return 0
    if self.has_request_ and self.request_ != x.request_: return 0
    return 1

  def IsInitialized(self, debug_strs=None):
    initialized = 1
    if (not self.has_service_name_):
      initialized = 0
      if debug_strs is not None:
        debug_strs.append('Required field: service_name not set.')
    if (not self.has_method_):
      initialized = 0
      if debug_strs is not None:
        debug_strs.append('Required field: method not set.')
    if (not self.has_request_):
      initialized = 0
      if debug_strs is not None:
        debug_strs.append('Required field: request not set.')
    elif not self.request_.IsInitialized(debug_strs): initialized = 0
    return initialized

  def ByteSize(self):
    n = 0
    n += self.lengthString(len(self.service_name_))
    n += self.lengthString(len(self.method_))
    n += self.lengthString(self.request_.ByteSize())
    return n + 3

  def ByteSizePartial(self):
    n = 0
    if (self.has_service_name_):
      n += 1
      n += self.lengthString(len(self.service_name_))
    if (self.has_method_):
      n += 1
      n += self.lengthString(len(self.method_))
    if (self.has_request_):
      n += 1
      n += self.lengthString(self.request_.ByteSizePartial())
    return n

  def Clear(self):
    self.clear_service_name()
    self.clear_method()
    self.clear_request()

  def OutputUnchecked(self, out):
    out.putVarInt32(18)
    out.putPrefixedString(self.service_name_)
    out.putVarInt32(26)
    out.putPrefixedString(self.method_)
    out.putVarInt32(34)
    out.putVarInt32(self.request_.ByteSize())
    self.request_.OutputUnchecked(out)

  def OutputPartial(self, out):
    if (self.has_service_name_):
      out.putVarInt32(18)
      out.putPrefixedString(self.service_name_)
    if (self.has_method_):
      out.putVarInt32(26)
      out.putPrefixedString(self.method_)
    if (self.has_request_):
      out.putVarInt32(34)
      out.putVarInt32(self.request_.ByteSizePartial())
      self.request_.OutputPartial(out)

  def TryMerge(self, d):
    while d.avail() > 0:
      tt = d.getVarInt32()
      if tt == 18:
        self.set_service_name(d.getPrefixedString())
        continue
      if tt == 26:
        self.set_method(d.getPrefixedString())
        continue
      if tt == 34:
        length = d.getVarInt32()
        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
        d.skip(length)
        self.mutable_request().TryMerge(tmp)
        continue
      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
      d.skipData(tt)


  def __str__(self, prefix="", printElemNumber=0):
    res=""
    if self.has_service_name_: res+=prefix+("service_name: %s\n" % self.DebugFormatString(self.service_name_))
    if self.has_method_: res+=prefix+("method: %s\n" % self.DebugFormatString(self.method_))
    if self.has_request_:
      res+=prefix+"request <\n"
      res+=self.request_.__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)])

  kservice_name = 2
  kmethod = 3
  krequest = 4

  _TEXT = _BuildTagLookupTable({
    0: "ErrorCode",
    2: "service_name",
    3: "method",
    4: "request",
  }, 4)

  _TYPES = _BuildTagLookupTable({
    0: ProtocolBuffer.Encoder.NUMERIC,
    2: ProtocolBuffer.Encoder.STRING,
    3: ProtocolBuffer.Encoder.STRING,
    4: ProtocolBuffer.Encoder.STRING,
  }, 4, ProtocolBuffer.Encoder.MAX_TYPE)

  _STYLE = """"""
  _STYLE_CONTENT_TYPE = """"""
Пример #11
0
class Response(ProtocolBuffer.ProtocolMessage):
  has_response_ = 0
  response_ = None
  has_exception_ = 0
  exception_ = None

  def __init__(self, contents=None):
    self.lazy_init_lock_ = thread.allocate_lock()
    if contents is not None: self.MergeFromString(contents)

  def response(self):
    if self.response_ is None:
      self.lazy_init_lock_.acquire()
      try:
        if self.response_ is None: self.response_ = RawMessage()
      finally:
        self.lazy_init_lock_.release()
    return self.response_

  def mutable_response(self): self.has_response_ = 1; return self.response()

  def clear_response(self):
    self.has_response_ = 0;
    if self.response_ is not None: self.response_.Clear()

  def has_response(self): return self.has_response_

  def exception(self):
    if self.exception_ is None:
      self.lazy_init_lock_.acquire()
      try:
        if self.exception_ is None: self.exception_ = RawMessage()
      finally:
        self.lazy_init_lock_.release()
    return self.exception_

  def mutable_exception(self): self.has_exception_ = 1; return self.exception()

  def clear_exception(self):
    self.has_exception_ = 0;
    if self.exception_ is not None: self.exception_.Clear()

  def has_exception(self): return self.has_exception_


  def MergeFrom(self, x):
    assert x is not self
    if (x.has_response()): self.mutable_response().MergeFrom(x.response())
    if (x.has_exception()): self.mutable_exception().MergeFrom(x.exception())

  def Equals(self, x):
    if x is self: return 1
    if self.has_response_ != x.has_response_: return 0
    if self.has_response_ and self.response_ != x.response_: return 0
    if self.has_exception_ != x.has_exception_: return 0
    if self.has_exception_ and self.exception_ != x.exception_: return 0
    return 1

  def IsInitialized(self, debug_strs=None):
    initialized = 1
    if (self.has_response_ and not self.response_.IsInitialized(debug_strs)): initialized = 0
    if (self.has_exception_ and not self.exception_.IsInitialized(debug_strs)): initialized = 0
    return initialized

  def ByteSize(self):
    n = 0
    if (self.has_response_): n += 1 + self.lengthString(self.response_.ByteSize())
    if (self.has_exception_): n += 1 + self.lengthString(self.exception_.ByteSize())
    return n + 0

  def Clear(self):
    self.clear_response()
    self.clear_exception()

  def OutputUnchecked(self, out):
    if (self.has_response_):
      out.putVarInt32(10)
      out.putVarInt32(self.response_.ByteSize())
      self.response_.OutputUnchecked(out)
    if (self.has_exception_):
      out.putVarInt32(18)
      out.putVarInt32(self.exception_.ByteSize())
      self.exception_.OutputUnchecked(out)

  def TryMerge(self, d):
    while d.avail() > 0:
      tt = d.getVarInt32()
      if tt == 10:
        length = d.getVarInt32()
        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
        d.skip(length)
        self.mutable_response().TryMerge(tmp)
        continue
      if tt == 18:
        length = d.getVarInt32()
        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
        d.skip(length)
        self.mutable_exception().TryMerge(tmp)
        continue
      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
      d.skipData(tt)


  def __str__(self, prefix="", printElemNumber=0):
    res=""
    if self.has_response_:
      res+=prefix+"response <\n"
      res+=self.response_.__str__(prefix + "  ", printElemNumber)
      res+=prefix+">\n"
    if self.has_exception_:
      res+=prefix+"exception <\n"
      res+=self.exception_.__str__(prefix + "  ", printElemNumber)
      res+=prefix+">\n"
    return res

  kresponse = 1
  kexception = 2

  _TEXT = (
   "ErrorCode",
   "response",
   "exception",
  )

  _TYPES = (
   ProtocolBuffer.Encoder.NUMERIC,
   ProtocolBuffer.Encoder.STRING,

   ProtocolBuffer.Encoder.STRING,

  )

  _STYLE = """"""
  _STYLE_CONTENT_TYPE = """"""
Пример #12
0
class Response(ProtocolBuffer.ProtocolMessage):
    has_response_ = 0
    response_ = None
    has_exception_ = 0
    exception_ = None

    def __init__(self, contents=None):
        self.lazy_init_lock_ = thread.allocate_lock()
        if contents is not None: self.MergeFromString(contents)

    def response(self):
        if self.response_ is None:
            self.lazy_init_lock_.acquire()
            try:
                if self.response_ is None: self.response_ = RawMessage()
            finally:
                self.lazy_init_lock_.release()
        return self.response_

    def mutable_response(self):
        self.has_response_ = 1
        return self.response()

    def clear_response(self):
        if self.has_response_:
            self.has_response_ = 0
            if self.response_ is not None: self.response_.Clear()

    def has_response(self):
        return self.has_response_

    def exception(self):
        if self.exception_ is None:
            self.lazy_init_lock_.acquire()
            try:
                if self.exception_ is None: self.exception_ = RawMessage()
            finally:
                self.lazy_init_lock_.release()
        return self.exception_

    def mutable_exception(self):
        self.has_exception_ = 1
        return self.exception()

    def clear_exception(self):
        if self.has_exception_:
            self.has_exception_ = 0
            if self.exception_ is not None: self.exception_.Clear()

    def has_exception(self):
        return self.has_exception_

    def MergeFrom(self, x):
        assert x is not self
        if (x.has_response()): self.mutable_response().MergeFrom(x.response())
        if (x.has_exception()):
            self.mutable_exception().MergeFrom(x.exception())

    def Equals(self, x):
        if x is self: return 1
        if self.has_response_ != x.has_response_: return 0
        if self.has_response_ and self.response_ != x.response_: return 0
        if self.has_exception_ != x.has_exception_: return 0
        if self.has_exception_ and self.exception_ != x.exception_: return 0
        return 1

    def IsInitialized(self, debug_strs=None):
        initialized = 1
        if (self.has_response_
                and not self.response_.IsInitialized(debug_strs)):
            initialized = 0
        if (self.has_exception_
                and not self.exception_.IsInitialized(debug_strs)):
            initialized = 0
        return initialized

    def ByteSize(self):
        n = 0
        if (self.has_response_):
            n += 1 + self.lengthString(self.response_.ByteSize())
        if (self.has_exception_):
            n += 1 + self.lengthString(self.exception_.ByteSize())
        return n + 0

    def Clear(self):
        self.clear_response()
        self.clear_exception()

    def OutputUnchecked(self, out):
        if (self.has_response_):
            out.putVarInt32(10)
            out.putVarInt32(self.response_.ByteSize())
            self.response_.OutputUnchecked(out)
        if (self.has_exception_):
            out.putVarInt32(18)
            out.putVarInt32(self.exception_.ByteSize())
            self.exception_.OutputUnchecked(out)

    def TryMerge(self, d):
        while d.avail() > 0:
            tt = d.getVarInt32()
            if tt == 10:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
                                             d.pos() + length)
                d.skip(length)
                self.mutable_response().TryMerge(tmp)
                continue
            if tt == 18:
                length = d.getVarInt32()
                tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(),
                                             d.pos() + length)
                d.skip(length)
                self.mutable_exception().TryMerge(tmp)
                continue
            if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
            d.skipData(tt)

    def __str__(self, prefix="", printElemNumber=0):
        res = ""
        if self.has_response_:
            res += prefix + "response <\n"
            res += self.response_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        if self.has_exception_:
            res += prefix + "exception <\n"
            res += self.exception_.__str__(prefix + "  ", printElemNumber)
            res += prefix + ">\n"
        return res

    kresponse = 1
    kexception = 2

    _TEXT = (
        "ErrorCode",
        "response",
        "exception",
    )

    _TYPES = (
        ProtocolBuffer.Encoder.NUMERIC,
        ProtocolBuffer.Encoder.STRING,
        ProtocolBuffer.Encoder.STRING,
    )

    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""