py_tasks_melange: comparison thirdparty/google_appengine/google/appengine/datastore/datastore

equal deleted inserted replaced

-:5c931bd3dc1e
+:a7766286a7be
 def set_handle(self, x):
 self.has_handle_ = 1
 self.handle_ = x
 def clear_handle(self):
-self.has_handle_ = 0
+if self.has_handle_:
-self.handle_ = 0
+self.has_handle_ = 0
+self.handle_ = 0
 def has_handle(self): return self.has_handle_
 def MergeFrom(self, x):
 def set_op(self, x):
 self.has_op_ = 1
 self.op_ = x
 def clear_op(self):
-self.has_op_ = 0
+if self.has_op_:
-self.op_ = 0
+self.has_op_ = 0
+self.op_ = 0
 def has_op(self): return self.has_op_
 def property_size(self): return len(self.property_)
 def property_list(self): return self.property_
 def set_property(self, x):
 self.has_property_ = 1
 self.property_ = x
 def clear_property(self):
-self.has_property_ = 0
+if self.has_property_:
-self.property_ = ""
+self.has_property_ = 0
+self.property_ = ""
 def has_property(self): return self.has_property_
 def direction(self): return self.direction_
 def set_direction(self, x):
 self.has_direction_ = 1
 self.direction_ = x
 def clear_direction(self):
-self.has_direction_ = 0
+if self.has_direction_:
-self.direction_ = 1
+self.has_direction_ = 0
+self.direction_ = 1
 def has_direction(self): return self.has_direction_
 def MergeFrom(self, x):
 def set_app(self, x):
 self.has_app_ = 1
 self.app_ = x
 def clear_app(self):
-self.has_app_ = 0
+if self.has_app_:
-self.app_ = ""
+self.has_app_ = 0
+self.app_ = ""
 def has_app(self): return self.has_app_
 def kind(self): return self.kind_
 def set_kind(self, x):
 self.has_kind_ = 1
 self.kind_ = x
 def clear_kind(self):
-self.has_kind_ = 0
+if self.has_kind_:
-self.kind_ = ""
+self.has_kind_ = 0
+self.kind_ = ""
 def has_kind(self): return self.has_kind_
 def ancestor(self):
 if self.ancestor_ is None:
 return self.ancestor_
 def mutable_ancestor(self): self.has_ancestor_ = 1; return self.ancestor()
 def clear_ancestor(self):
-self.has_ancestor_ = 0;
+if self.has_ancestor_:
-if self.ancestor_ is not None: self.ancestor_.Clear()
+self.has_ancestor_ = 0;
+if self.ancestor_ is not None: self.ancestor_.Clear()
 def has_ancestor(self): return self.has_ancestor_
 def filter_size(self): return len(self.filter_)
 def filter_list(self): return self.filter_
 def set_search_query(self, x):
 self.has_search_query_ = 1
 self.search_query_ = x
 def clear_search_query(self):
-self.has_search_query_ = 0
+if self.has_search_query_:
-self.search_query_ = ""
+self.has_search_query_ = 0
+self.search_query_ = ""
 def has_search_query(self): return self.has_search_query_
 def order_size(self): return len(self.order_)
 def order_list(self): return self.order_
 def set_hint(self, x):
 self.has_hint_ = 1
 self.hint_ = x
 def clear_hint(self):
-self.has_hint_ = 0
+if self.has_hint_:
-self.hint_ = 0
+self.has_hint_ = 0
+self.hint_ = 0
 def has_hint(self): return self.has_hint_
 def offset(self): return self.offset_
 def set_offset(self, x):
 self.has_offset_ = 1
 self.offset_ = x
 def clear_offset(self):
-self.has_offset_ = 0
+if self.has_offset_:
-self.offset_ = 0
+self.has_offset_ = 0
+self.offset_ = 0
 def has_offset(self): return self.has_offset_
 def limit(self): return self.limit_
 def set_limit(self, x):
 self.has_limit_ = 1
 self.limit_ = x
 def clear_limit(self):
-self.has_limit_ = 0
+if self.has_limit_:
-self.limit_ = 0
+self.has_limit_ = 0
+self.limit_ = 0
 def has_limit(self): return self.has_limit_
 def composite_index_size(self): return len(self.composite_index_)
 def composite_index_list(self): return self.composite_index_
 def set_require_perfect_plan(self, x):
 self.has_require_perfect_plan_ = 1
 self.require_perfect_plan_ = x
 def clear_require_perfect_plan(self):
-self.has_require_perfect_plan_ = 0
+if self.has_require_perfect_plan_:
-self.require_perfect_plan_ = 0
+self.has_require_perfect_plan_ = 0
+self.require_perfect_plan_ = 0
 def has_require_perfect_plan(self): return self.has_require_perfect_plan_
 def MergeFrom(self, x):
 def set_native_ancestor(self, x):
 self.has_native_ancestor_ = 1
 self.native_ancestor_ = x
 def clear_native_ancestor(self):
-self.has_native_ancestor_ = 0
+if self.has_native_ancestor_:
-self.native_ancestor_ = 0
+self.has_native_ancestor_ = 0
+self.native_ancestor_ = 0
 def has_native_ancestor(self): return self.has_native_ancestor_
 def native_index_size(self): return len(self.native_index_)
 def native_index_list(self): return self.native_index_
 def set_native_offset(self, x):
 self.has_native_offset_ = 1
 self.native_offset_ = x
 def clear_native_offset(self):
-self.has_native_offset_ = 0
+if self.has_native_offset_:
-self.native_offset_ = 0
+self.has_native_offset_ = 0
+self.native_offset_ = 0
 def has_native_offset(self): return self.has_native_offset_
 def native_limit(self): return self.native_limit_
 def set_native_limit(self, x):
 self.has_native_limit_ = 1
 self.native_limit_ = x
 def clear_native_limit(self):
-self.has_native_limit_ = 0
+if self.has_native_limit_:
-self.native_limit_ = 0
+self.has_native_limit_ = 0
+self.native_limit_ = 0
 def has_native_limit(self): return self.has_native_limit_
 def MergeFrom(self, x):
 def set_cursor(self, x):
 self.has_cursor_ = 1
 self.cursor_ = x
 def clear_cursor(self):
-self.has_cursor_ = 0
+if self.has_cursor_:
-self.cursor_ = 0
+self.has_cursor_ = 0
+self.cursor_ = 0
 def has_cursor(self): return self.has_cursor_
 def MergeFrom(self, x):
 def set_index_writes(self, x):
 self.has_index_writes_ = 1
 self.index_writes_ = x
 def clear_index_writes(self):
-self.has_index_writes_ = 0
+if self.has_index_writes_:
-self.index_writes_ = 0
+self.has_index_writes_ = 0
+self.index_writes_ = 0
 def has_index_writes(self): return self.has_index_writes_
 def MergeFrom(self, x):
 return self.transaction_
 def mutable_transaction(self): self.has_transaction_ = 1; return self.transaction()
 def clear_transaction(self):
-self.has_transaction_ = 0;
+if self.has_transaction_:
-if self.transaction_ is not None: self.transaction_.Clear()
+self.has_transaction_ = 0;
+if self.transaction_ is not None: self.transaction_.Clear()
 def has_transaction(self): return self.has_transaction_
 def MergeFrom(self, x):
 return self.entity_
 def mutable_entity(self): self.has_entity_ = 1; return self.entity()
 def clear_entity(self):
-self.has_entity_ = 0;
+if self.has_entity_:
-if self.entity_ is not None: self.entity_.Clear()
+self.has_entity_ = 0;
+if self.entity_ is not None: self.entity_.Clear()
 def has_entity(self): return self.has_entity_
 def MergeFrom(self, x):
 _STYLE = """"""
 _STYLE_CONTENT_TYPE = """"""
 class PutRequest(ProtocolBuffer.ProtocolMessage):
 has_transaction_ = 0
 transaction_ = None
+has_trusted_ = 0
+trusted_ = 0
 def __init__(self, contents=None):
 self.entity_ = []
 self.composite_index_ = []
 self.lazy_init_lock_ = thread.allocate_lock()
 return self.transaction_
 def mutable_transaction(self): self.has_transaction_ = 1; return self.transaction()
 def clear_transaction(self):
-self.has_transaction_ = 0;
+if self.has_transaction_:
-if self.transaction_ is not None: self.transaction_.Clear()
+self.has_transaction_ = 0;
+if self.transaction_ is not None: self.transaction_.Clear()
 def has_transaction(self): return self.has_transaction_
 def composite_index_size(self): return len(self.composite_index_)
 def composite_index_list(self): return self.composite_index_
 self.composite_index_.append(x)
 return x
 def clear_composite_index(self):
 self.composite_index_ = []
+def trusted(self): return self.trusted_
+def set_trusted(self, x):
+self.has_trusted_ = 1
+self.trusted_ = x
+def clear_trusted(self):
+if self.has_trusted_:
+self.has_trusted_ = 0
+self.trusted_ = 0
+def has_trusted(self): return self.has_trusted_
 def MergeFrom(self, x):
 assert x is not self
 for i in xrange(x.entity_size()): self.add_entity().CopyFrom(x.entity(i))
 if (x.has_transaction()): self.mutable_transaction().MergeFrom(x.transaction())
 for i in xrange(x.composite_index_size()): self.add_composite_index().CopyFrom(x.composite_index(i))
+if (x.has_trusted()): self.set_trusted(x.trusted())
 def Equals(self, x):
 if x is self: return 1
 if len(self.entity_) != len(x.entity_): return 0
 for e1, e2 in zip(self.entity_, x.entity_):
 if self.has_transaction_ != x.has_transaction_: return 0
 if self.has_transaction_ and self.transaction_ != x.transaction_: return 0
 if len(self.composite_index_) != len(x.composite_index_): return 0
 for e1, e2 in zip(self.composite_index_, x.composite_index_):
 if e1 != e2: return 0
+if self.has_trusted_ != x.has_trusted_: return 0
+if self.has_trusted_ and self.trusted_ != x.trusted_: return 0
 return 1
 def IsInitialized(self, debug_strs=None):
 initialized = 1
 for p in self.entity_:
 n += 1 * len(self.entity_)
 for i in xrange(len(self.entity_)): n += self.lengthString(self.entity_[i].ByteSize())
 if (self.has_transaction_): n += 1 + self.lengthString(self.transaction_.ByteSize())
 n += 1 * len(self.composite_index_)
 for i in xrange(len(self.composite_index_)): n += self.lengthString(self.composite_index_[i].ByteSize())
+if (self.has_trusted_): n += 2
 return n + 0
 def Clear(self):
 self.clear_entity()
 self.clear_transaction()
 self.clear_composite_index()
+self.clear_trusted()
 def OutputUnchecked(self, out):
 for i in xrange(len(self.entity_)):
 out.putVarInt32(10)
 out.putVarInt32(self.entity_[i].ByteSize())
 self.transaction_.OutputUnchecked(out)
 for i in xrange(len(self.composite_index_)):
 out.putVarInt32(26)
 out.putVarInt32(self.composite_index_[i].ByteSize())
 self.composite_index_[i].OutputUnchecked(out)
+if (self.has_trusted_):
+out.putVarInt32(32)
+out.putBoolean(self.trusted_)
 def TryMerge(self, d):
 while d.avail() > 0:
 tt = d.getVarInt32()
 if tt == 10:
 if tt == 26:
 length = d.getVarInt32()
 tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 d.skip(length)
 self.add_composite_index().TryMerge(tmp)
+continue
+if tt == 32:
+self.set_trusted(d.getBoolean())
 continue
 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 d.skipData(tt)
 if printElemNumber: elm="(%d)" % cnt
 res+=prefix+("composite_index%s <\n" % elm)
 res+=e.__str__(prefix + "  ", printElemNumber)
 res+=prefix+">\n"
 cnt+=1
+if self.has_trusted_: res+=prefix+("trusted: %s\n" % self.DebugFormatBool(self.trusted_))
 return res
 kentity = 1
 ktransaction = 2
 kcomposite_index = 3
+ktrusted = 4
 _TEXT = (
 "ErrorCode",
 "entity",
 "transaction",
 "composite_index",
+"trusted",
 )
 _TYPES = (
 ProtocolBuffer.Encoder.NUMERIC,
 ProtocolBuffer.Encoder.STRING,
 ProtocolBuffer.Encoder.STRING,
 ProtocolBuffer.Encoder.STRING,
+ProtocolBuffer.Encoder.NUMERIC,
 )
 _STYLE = """"""
 _STYLE_CONTENT_TYPE = """"""
 return self.cost_
 def mutable_cost(self): self.has_cost_ = 1; return self.cost()
 def clear_cost(self):
-self.has_cost_ = 0;
+if self.has_cost_:
-if self.cost_ is not None: self.cost_.Clear()
+self.has_cost_ = 0;
+if self.cost_ is not None: self.cost_.Clear()
 def has_cost(self): return self.has_cost_
 def MergeFrom(self, x):
 _STYLE = """"""
 _STYLE_CONTENT_TYPE = """"""
 class DeleteRequest(ProtocolBuffer.ProtocolMessage):
 has_transaction_ = 0
 transaction_ = None
+has_trusted_ = 0
+trusted_ = 0
 def __init__(self, contents=None):
 self.key_ = []
 self.lazy_init_lock_ = thread.allocate_lock()
 if contents is not None: self.MergeFromString(contents)
 return self.transaction_
 def mutable_transaction(self): self.has_transaction_ = 1; return self.transaction()
 def clear_transaction(self):
-self.has_transaction_ = 0;
+if self.has_transaction_:
-if self.transaction_ is not None: self.transaction_.Clear()
+self.has_transaction_ = 0;
+if self.transaction_ is not None: self.transaction_.Clear()
 def has_transaction(self): return self.has_transaction_
+def trusted(self): return self.trusted_
+def set_trusted(self, x):
+self.has_trusted_ = 1
+self.trusted_ = x
+def clear_trusted(self):
+if self.has_trusted_:
+self.has_trusted_ = 0
+self.trusted_ = 0
+def has_trusted(self): return self.has_trusted_
 def MergeFrom(self, x):
 assert x is not self
 for i in xrange(x.key_size()): self.add_key().CopyFrom(x.key(i))
 if (x.has_transaction()): self.mutable_transaction().MergeFrom(x.transaction())
+if (x.has_trusted()): self.set_trusted(x.trusted())
 def Equals(self, x):
 if x is self: return 1
 if len(self.key_) != len(x.key_): return 0
 for e1, e2 in zip(self.key_, x.key_):
 if e1 != e2: return 0
 if self.has_transaction_ != x.has_transaction_: return 0
 if self.has_transaction_ and self.transaction_ != x.transaction_: return 0
+if self.has_trusted_ != x.has_trusted_: return 0
+if self.has_trusted_ and self.trusted_ != x.trusted_: return 0
 return 1
 def IsInitialized(self, debug_strs=None):
 initialized = 1
 for p in self.key_:
 def ByteSize(self):
 n = 0
 n += 1 * len(self.key_)
 for i in xrange(len(self.key_)): n += self.lengthString(self.key_[i].ByteSize())
 if (self.has_transaction_): n += 1 + self.lengthString(self.transaction_.ByteSize())
+if (self.has_trusted_): n += 2
 return n + 0
 def Clear(self):
 self.clear_key()
 self.clear_transaction()
+self.clear_trusted()
 def OutputUnchecked(self, out):
+if (self.has_trusted_):
+out.putVarInt32(32)
+out.putBoolean(self.trusted_)
 if (self.has_transaction_):
 out.putVarInt32(42)
 out.putVarInt32(self.transaction_.ByteSize())
 self.transaction_.OutputUnchecked(out)
 for i in xrange(len(self.key_)):
 self.key_[i].OutputUnchecked(out)
 def TryMerge(self, d):
 while d.avail() > 0:
 tt = d.getVarInt32()
+if tt == 32:
+self.set_trusted(d.getBoolean())
+continue
 if tt == 42:
 length = d.getVarInt32()
 tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 d.skip(length)
 self.mutable_transaction().TryMerge(tmp)
 cnt+=1
 if self.has_transaction_:
 res+=prefix+"transaction <\n"
 res+=self.transaction_.__str__(prefix + "  ", printElemNumber)
 res+=prefix+">\n"
+if self.has_trusted_: res+=prefix+("trusted: %s\n" % self.DebugFormatBool(self.trusted_))
 return res
 kkey = 6
 ktransaction = 5
+ktrusted = 4
 _TEXT = (
 "ErrorCode",
 None,
 None,
 None,
-None,
+"trusted",
 "transaction",
 "key",
 )
 _TYPES = (
 ProtocolBuffer.Encoder.MAX_TYPE,
 ProtocolBuffer.Encoder.MAX_TYPE,
-ProtocolBuffer.Encoder.MAX_TYPE,
+ProtocolBuffer.Encoder.NUMERIC,
 ProtocolBuffer.Encoder.STRING,
 ProtocolBuffer.Encoder.STRING,
 return self.cost_
 def mutable_cost(self): self.has_cost_ = 1; return self.cost()
 def clear_cost(self):
-self.has_cost_ = 0;
+if self.has_cost_:
-if self.cost_ is not None: self.cost_.Clear()
+self.has_cost_ = 0;
+if self.cost_ is not None: self.cost_.Clear()
 def has_cost(self): return self.has_cost_
 def MergeFrom(self, x):
 def set_count(self, x):
 self.has_count_ = 1
 self.count_ = x
 def clear_count(self):
-self.has_count_ = 0
+if self.has_count_:
-self.count_ = 1
+self.has_count_ = 0
+self.count_ = 1
 def has_count(self): return self.has_count_
 def MergeFrom(self, x):
 return self.cursor_
 def mutable_cursor(self): self.has_cursor_ = 1; return self.cursor()
 def clear_cursor(self):
-self.has_cursor_ = 0;
+if self.has_cursor_:
-if self.cursor_ is not None: self.cursor_.Clear()
+self.has_cursor_ = 0;
+if self.cursor_ is not None: self.cursor_.Clear()
 def has_cursor(self): return self.has_cursor_
 def result_size(self): return len(self.result_)
 def result_list(self): return self.result_
 def set_more_results(self, x):
 self.has_more_results_ = 1
 self.more_results_ = x
 def clear_more_results(self):
-self.has_more_results_ = 0
+if self.has_more_results_:
-self.more_results_ = 0
+self.has_more_results_ = 0
+self.more_results_ = 0
 def has_more_results(self): return self.has_more_results_
 def MergeFrom(self, x):
 )
 _STYLE = """"""
 _STYLE_CONTENT_TYPE = """"""
+class CommitResponse(ProtocolBuffer.ProtocolMessage):
-__all__ = ['Transaction','Query','Query_Filter','Query_Order','QueryExplanation','Cursor','Error','Cost','GetRequest','GetResponse','GetResponse_Entity','PutRequest','PutResponse','DeleteRequest','DeleteResponse','NextRequest','QueryResult','Schema','CompositeIndices']
+has_cost_ = 0
+cost_ = None
+def __init__(self, contents=None):
+self.lazy_init_lock_ = thread.allocate_lock()
+if contents is not None: self.MergeFromString(contents)
+def cost(self):
+if self.cost_ is None:
+self.lazy_init_lock_.acquire()
+try:
+if self.cost_ is None: self.cost_ = Cost()
+finally:
+self.lazy_init_lock_.release()
+return self.cost_
+def mutable_cost(self): self.has_cost_ = 1; return self.cost()
+def clear_cost(self):
+if self.has_cost_:
+self.has_cost_ = 0;
+if self.cost_ is not None: self.cost_.Clear()
+def has_cost(self): return self.has_cost_
+def MergeFrom(self, x):
+assert x is not self
+if (x.has_cost()): self.mutable_cost().MergeFrom(x.cost())
+def Equals(self, x):
+if x is self: return 1
+if self.has_cost_ != x.has_cost_: return 0
+if self.has_cost_ and self.cost_ != x.cost_: return 0
+return 1
+def IsInitialized(self, debug_strs=None):
+initialized = 1
+if (self.has_cost_ and not self.cost_.IsInitialized(debug_strs)): initialized = 0
+return initialized
+def ByteSize(self):
+n = 0
+if (self.has_cost_): n += 1 + self.lengthString(self.cost_.ByteSize())
+return n + 0
+def Clear(self):
+self.clear_cost()
+def OutputUnchecked(self, out):
+if (self.has_cost_):
+out.putVarInt32(10)
+out.putVarInt32(self.cost_.ByteSize())
+self.cost_.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_cost().TryMerge(tmp)
+continue
+if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
+d.skipData(tt)
+def __str__(self, prefix="", printElemNumber=0):
+res=""
+if self.has_cost_:
+res+=prefix+"cost <\n"
+res+=self.cost_.__str__(prefix + "  ", printElemNumber)
+res+=prefix+">\n"
+return res
+kcost = 1
+_TEXT = (
+"ErrorCode",
+"cost",
+)
+_TYPES = (
+ProtocolBuffer.Encoder.NUMERIC,
+ProtocolBuffer.Encoder.STRING,
+)
+_STYLE = """"""
+_STYLE_CONTENT_TYPE = """"""
+__all__ = ['Transaction','Query','Query_Filter','Query_Order','QueryExplanation','Cursor','Error','Cost','GetRequest','GetResponse','GetResponse_Entity','PutRequest','PutResponse','DeleteRequest','DeleteResponse','NextRequest','QueryResult','Schema','CompositeIndices','CommitResponse']

changeset 1278	a7766286a7be
parent 828	f5fd65cc3bf3
child 2273	e4cb9c53db3e