thirdparty/google_appengine/google/appengine/api/memcache/memcache_service_pb.py
changeset 1278 a7766286a7be
parent 828 f5fd65cc3bf3
child 2273 e4cb9c53db3e
equal deleted inserted replaced
1277:5c931bd3dc1e 1278:a7766286a7be
   187   def set_key(self, x):
   187   def set_key(self, x):
   188     self.has_key_ = 1
   188     self.has_key_ = 1
   189     self.key_ = x
   189     self.key_ = x
   190 
   190 
   191   def clear_key(self):
   191   def clear_key(self):
   192     self.has_key_ = 0
   192     if self.has_key_:
   193     self.key_ = ""
   193       self.has_key_ = 0
       
   194       self.key_ = ""
   194 
   195 
   195   def has_key(self): return self.has_key_
   196   def has_key(self): return self.has_key_
   196 
   197 
   197   def value(self): return self.value_
   198   def value(self): return self.value_
   198 
   199 
   199   def set_value(self, x):
   200   def set_value(self, x):
   200     self.has_value_ = 1
   201     self.has_value_ = 1
   201     self.value_ = x
   202     self.value_ = x
   202 
   203 
   203   def clear_value(self):
   204   def clear_value(self):
   204     self.has_value_ = 0
   205     if self.has_value_:
   205     self.value_ = ""
   206       self.has_value_ = 0
       
   207       self.value_ = ""
   206 
   208 
   207   def has_value(self): return self.has_value_
   209   def has_value(self): return self.has_value_
   208 
   210 
   209   def flags(self): return self.flags_
   211   def flags(self): return self.flags_
   210 
   212 
   211   def set_flags(self, x):
   213   def set_flags(self, x):
   212     self.has_flags_ = 1
   214     self.has_flags_ = 1
   213     self.flags_ = x
   215     self.flags_ = x
   214 
   216 
   215   def clear_flags(self):
   217   def clear_flags(self):
   216     self.has_flags_ = 0
   218     if self.has_flags_:
   217     self.flags_ = 0
   219       self.has_flags_ = 0
       
   220       self.flags_ = 0
   218 
   221 
   219   def has_flags(self): return self.has_flags_
   222   def has_flags(self): return self.has_flags_
   220 
   223 
   221 
   224 
   222   def MergeFrom(self, x):
   225   def MergeFrom(self, x):
   416   def set_key(self, x):
   419   def set_key(self, x):
   417     self.has_key_ = 1
   420     self.has_key_ = 1
   418     self.key_ = x
   421     self.key_ = x
   419 
   422 
   420   def clear_key(self):
   423   def clear_key(self):
   421     self.has_key_ = 0
   424     if self.has_key_:
   422     self.key_ = ""
   425       self.has_key_ = 0
       
   426       self.key_ = ""
   423 
   427 
   424   def has_key(self): return self.has_key_
   428   def has_key(self): return self.has_key_
   425 
   429 
   426   def value(self): return self.value_
   430   def value(self): return self.value_
   427 
   431 
   428   def set_value(self, x):
   432   def set_value(self, x):
   429     self.has_value_ = 1
   433     self.has_value_ = 1
   430     self.value_ = x
   434     self.value_ = x
   431 
   435 
   432   def clear_value(self):
   436   def clear_value(self):
   433     self.has_value_ = 0
   437     if self.has_value_:
   434     self.value_ = ""
   438       self.has_value_ = 0
       
   439       self.value_ = ""
   435 
   440 
   436   def has_value(self): return self.has_value_
   441   def has_value(self): return self.has_value_
   437 
   442 
   438   def flags(self): return self.flags_
   443   def flags(self): return self.flags_
   439 
   444 
   440   def set_flags(self, x):
   445   def set_flags(self, x):
   441     self.has_flags_ = 1
   446     self.has_flags_ = 1
   442     self.flags_ = x
   447     self.flags_ = x
   443 
   448 
   444   def clear_flags(self):
   449   def clear_flags(self):
   445     self.has_flags_ = 0
   450     if self.has_flags_:
   446     self.flags_ = 0
   451       self.has_flags_ = 0
       
   452       self.flags_ = 0
   447 
   453 
   448   def has_flags(self): return self.has_flags_
   454   def has_flags(self): return self.has_flags_
   449 
   455 
   450   def set_policy(self): return self.set_policy_
   456   def set_policy(self): return self.set_policy_
   451 
   457 
   452   def set_set_policy(self, x):
   458   def set_set_policy(self, x):
   453     self.has_set_policy_ = 1
   459     self.has_set_policy_ = 1
   454     self.set_policy_ = x
   460     self.set_policy_ = x
   455 
   461 
   456   def clear_set_policy(self):
   462   def clear_set_policy(self):
   457     self.has_set_policy_ = 0
   463     if self.has_set_policy_:
   458     self.set_policy_ = 1
   464       self.has_set_policy_ = 0
       
   465       self.set_policy_ = 1
   459 
   466 
   460   def has_set_policy(self): return self.has_set_policy_
   467   def has_set_policy(self): return self.has_set_policy_
   461 
   468 
   462   def expiration_time(self): return self.expiration_time_
   469   def expiration_time(self): return self.expiration_time_
   463 
   470 
   464   def set_expiration_time(self, x):
   471   def set_expiration_time(self, x):
   465     self.has_expiration_time_ = 1
   472     self.has_expiration_time_ = 1
   466     self.expiration_time_ = x
   473     self.expiration_time_ = x
   467 
   474 
   468   def clear_expiration_time(self):
   475   def clear_expiration_time(self):
   469     self.has_expiration_time_ = 0
   476     if self.has_expiration_time_:
   470     self.expiration_time_ = 0
   477       self.has_expiration_time_ = 0
       
   478       self.expiration_time_ = 0
   471 
   479 
   472   def has_expiration_time(self): return self.has_expiration_time_
   480   def has_expiration_time(self): return self.has_expiration_time_
   473 
   481 
   474 
   482 
   475   def MergeFrom(self, x):
   483   def MergeFrom(self, x):
   809   def set_key(self, x):
   817   def set_key(self, x):
   810     self.has_key_ = 1
   818     self.has_key_ = 1
   811     self.key_ = x
   819     self.key_ = x
   812 
   820 
   813   def clear_key(self):
   821   def clear_key(self):
   814     self.has_key_ = 0
   822     if self.has_key_:
   815     self.key_ = ""
   823       self.has_key_ = 0
       
   824       self.key_ = ""
   816 
   825 
   817   def has_key(self): return self.has_key_
   826   def has_key(self): return self.has_key_
   818 
   827 
   819   def delete_time(self): return self.delete_time_
   828   def delete_time(self): return self.delete_time_
   820 
   829 
   821   def set_delete_time(self, x):
   830   def set_delete_time(self, x):
   822     self.has_delete_time_ = 1
   831     self.has_delete_time_ = 1
   823     self.delete_time_ = x
   832     self.delete_time_ = x
   824 
   833 
   825   def clear_delete_time(self):
   834   def clear_delete_time(self):
   826     self.has_delete_time_ = 0
   835     if self.has_delete_time_:
   827     self.delete_time_ = 0
   836       self.has_delete_time_ = 0
       
   837       self.delete_time_ = 0
   828 
   838 
   829   def has_delete_time(self): return self.has_delete_time_
   839   def has_delete_time(self): return self.has_delete_time_
   830 
   840 
   831 
   841 
   832   def MergeFrom(self, x):
   842   def MergeFrom(self, x):
  1113   def set_key(self, x):
  1123   def set_key(self, x):
  1114     self.has_key_ = 1
  1124     self.has_key_ = 1
  1115     self.key_ = x
  1125     self.key_ = x
  1116 
  1126 
  1117   def clear_key(self):
  1127   def clear_key(self):
  1118     self.has_key_ = 0
  1128     if self.has_key_:
  1119     self.key_ = ""
  1129       self.has_key_ = 0
       
  1130       self.key_ = ""
  1120 
  1131 
  1121   def has_key(self): return self.has_key_
  1132   def has_key(self): return self.has_key_
  1122 
  1133 
  1123   def delta(self): return self.delta_
  1134   def delta(self): return self.delta_
  1124 
  1135 
  1125   def set_delta(self, x):
  1136   def set_delta(self, x):
  1126     self.has_delta_ = 1
  1137     self.has_delta_ = 1
  1127     self.delta_ = x
  1138     self.delta_ = x
  1128 
  1139 
  1129   def clear_delta(self):
  1140   def clear_delta(self):
  1130     self.has_delta_ = 0
  1141     if self.has_delta_:
  1131     self.delta_ = 1
  1142       self.has_delta_ = 0
       
  1143       self.delta_ = 1
  1132 
  1144 
  1133   def has_delta(self): return self.has_delta_
  1145   def has_delta(self): return self.has_delta_
  1134 
  1146 
  1135   def direction(self): return self.direction_
  1147   def direction(self): return self.direction_
  1136 
  1148 
  1137   def set_direction(self, x):
  1149   def set_direction(self, x):
  1138     self.has_direction_ = 1
  1150     self.has_direction_ = 1
  1139     self.direction_ = x
  1151     self.direction_ = x
  1140 
  1152 
  1141   def clear_direction(self):
  1153   def clear_direction(self):
  1142     self.has_direction_ = 0
  1154     if self.has_direction_:
  1143     self.direction_ = 1
  1155       self.has_direction_ = 0
       
  1156       self.direction_ = 1
  1144 
  1157 
  1145   def has_direction(self): return self.has_direction_
  1158   def has_direction(self): return self.has_direction_
  1146 
  1159 
  1147 
  1160 
  1148   def MergeFrom(self, x):
  1161   def MergeFrom(self, x):
  1249   def set_new_value(self, x):
  1262   def set_new_value(self, x):
  1250     self.has_new_value_ = 1
  1263     self.has_new_value_ = 1
  1251     self.new_value_ = x
  1264     self.new_value_ = x
  1252 
  1265 
  1253   def clear_new_value(self):
  1266   def clear_new_value(self):
  1254     self.has_new_value_ = 0
  1267     if self.has_new_value_:
  1255     self.new_value_ = 0
  1268       self.has_new_value_ = 0
       
  1269       self.new_value_ = 0
  1256 
  1270 
  1257   def has_new_value(self): return self.has_new_value_
  1271   def has_new_value(self): return self.has_new_value_
  1258 
  1272 
  1259 
  1273 
  1260   def MergeFrom(self, x):
  1274   def MergeFrom(self, x):
  1486   def set_hits(self, x):
  1500   def set_hits(self, x):
  1487     self.has_hits_ = 1
  1501     self.has_hits_ = 1
  1488     self.hits_ = x
  1502     self.hits_ = x
  1489 
  1503 
  1490   def clear_hits(self):
  1504   def clear_hits(self):
  1491     self.has_hits_ = 0
  1505     if self.has_hits_:
  1492     self.hits_ = 0
  1506       self.has_hits_ = 0
       
  1507       self.hits_ = 0
  1493 
  1508 
  1494   def has_hits(self): return self.has_hits_
  1509   def has_hits(self): return self.has_hits_
  1495 
  1510 
  1496   def misses(self): return self.misses_
  1511   def misses(self): return self.misses_
  1497 
  1512 
  1498   def set_misses(self, x):
  1513   def set_misses(self, x):
  1499     self.has_misses_ = 1
  1514     self.has_misses_ = 1
  1500     self.misses_ = x
  1515     self.misses_ = x
  1501 
  1516 
  1502   def clear_misses(self):
  1517   def clear_misses(self):
  1503     self.has_misses_ = 0
  1518     if self.has_misses_:
  1504     self.misses_ = 0
  1519       self.has_misses_ = 0
       
  1520       self.misses_ = 0
  1505 
  1521 
  1506   def has_misses(self): return self.has_misses_
  1522   def has_misses(self): return self.has_misses_
  1507 
  1523 
  1508   def byte_hits(self): return self.byte_hits_
  1524   def byte_hits(self): return self.byte_hits_
  1509 
  1525 
  1510   def set_byte_hits(self, x):
  1526   def set_byte_hits(self, x):
  1511     self.has_byte_hits_ = 1
  1527     self.has_byte_hits_ = 1
  1512     self.byte_hits_ = x
  1528     self.byte_hits_ = x
  1513 
  1529 
  1514   def clear_byte_hits(self):
  1530   def clear_byte_hits(self):
  1515     self.has_byte_hits_ = 0
  1531     if self.has_byte_hits_:
  1516     self.byte_hits_ = 0
  1532       self.has_byte_hits_ = 0
       
  1533       self.byte_hits_ = 0
  1517 
  1534 
  1518   def has_byte_hits(self): return self.has_byte_hits_
  1535   def has_byte_hits(self): return self.has_byte_hits_
  1519 
  1536 
  1520   def items(self): return self.items_
  1537   def items(self): return self.items_
  1521 
  1538 
  1522   def set_items(self, x):
  1539   def set_items(self, x):
  1523     self.has_items_ = 1
  1540     self.has_items_ = 1
  1524     self.items_ = x
  1541     self.items_ = x
  1525 
  1542 
  1526   def clear_items(self):
  1543   def clear_items(self):
  1527     self.has_items_ = 0
  1544     if self.has_items_:
  1528     self.items_ = 0
  1545       self.has_items_ = 0
       
  1546       self.items_ = 0
  1529 
  1547 
  1530   def has_items(self): return self.has_items_
  1548   def has_items(self): return self.has_items_
  1531 
  1549 
  1532   def bytes(self): return self.bytes_
  1550   def bytes(self): return self.bytes_
  1533 
  1551 
  1534   def set_bytes(self, x):
  1552   def set_bytes(self, x):
  1535     self.has_bytes_ = 1
  1553     self.has_bytes_ = 1
  1536     self.bytes_ = x
  1554     self.bytes_ = x
  1537 
  1555 
  1538   def clear_bytes(self):
  1556   def clear_bytes(self):
  1539     self.has_bytes_ = 0
  1557     if self.has_bytes_:
  1540     self.bytes_ = 0
  1558       self.has_bytes_ = 0
       
  1559       self.bytes_ = 0
  1541 
  1560 
  1542   def has_bytes(self): return self.has_bytes_
  1561   def has_bytes(self): return self.has_bytes_
  1543 
  1562 
  1544   def oldest_item_age(self): return self.oldest_item_age_
  1563   def oldest_item_age(self): return self.oldest_item_age_
  1545 
  1564 
  1546   def set_oldest_item_age(self, x):
  1565   def set_oldest_item_age(self, x):
  1547     self.has_oldest_item_age_ = 1
  1566     self.has_oldest_item_age_ = 1
  1548     self.oldest_item_age_ = x
  1567     self.oldest_item_age_ = x
  1549 
  1568 
  1550   def clear_oldest_item_age(self):
  1569   def clear_oldest_item_age(self):
  1551     self.has_oldest_item_age_ = 0
  1570     if self.has_oldest_item_age_:
  1552     self.oldest_item_age_ = 0
  1571       self.has_oldest_item_age_ = 0
       
  1572       self.oldest_item_age_ = 0
  1553 
  1573 
  1554   def has_oldest_item_age(self): return self.has_oldest_item_age_
  1574   def has_oldest_item_age(self): return self.has_oldest_item_age_
  1555 
  1575 
  1556 
  1576 
  1557   def MergeFrom(self, x):
  1577   def MergeFrom(self, x):
  1726     return self.stats_
  1746     return self.stats_
  1727 
  1747 
  1728   def mutable_stats(self): self.has_stats_ = 1; return self.stats()
  1748   def mutable_stats(self): self.has_stats_ = 1; return self.stats()
  1729 
  1749 
  1730   def clear_stats(self):
  1750   def clear_stats(self):
  1731     self.has_stats_ = 0;
  1751     if self.has_stats_:
  1732     if self.stats_ is not None: self.stats_.Clear()
  1752       self.has_stats_ = 0;
       
  1753       if self.stats_ is not None: self.stats_.Clear()
  1733 
  1754 
  1734   def has_stats(self): return self.has_stats_
  1755   def has_stats(self): return self.has_stats_
  1735 
  1756 
  1736 
  1757 
  1737   def MergeFrom(self, x):
  1758   def MergeFrom(self, x):