|
1 #!/usr/bin/env python |
|
2 # |
|
3 # Copyright 2007 Google Inc. |
|
4 # |
|
5 # Licensed under the Apache License, Version 2.0 (the "License"); |
|
6 # you may not use this file except in compliance with the License. |
|
7 # You may obtain a copy of the License at |
|
8 # |
|
9 # http://www.apache.org/licenses/LICENSE-2.0 |
|
10 # |
|
11 # Unless required by applicable law or agreed to in writing, software |
|
12 # distributed under the License is distributed on an "AS IS" BASIS, |
|
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
14 # See the License for the specific language governing permissions and |
|
15 # limitations under the License. |
|
16 # |
|
17 |
|
18 from google.net.proto import ProtocolBuffer |
|
19 import array |
|
20 import dummy_thread as thread |
|
21 |
|
22 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit |
|
23 unusednames=printElemNumber,debug_strs no-special""" |
|
24 |
|
25 from google.appengine.base.capabilities_pb import CapabilityConfig |
|
26 class IsEnabledRequest(ProtocolBuffer.ProtocolMessage): |
|
27 has_package_ = 0 |
|
28 package_ = "" |
|
29 |
|
30 def __init__(self, contents=None): |
|
31 self.capability_ = [] |
|
32 self.call_ = [] |
|
33 if contents is not None: self.MergeFromString(contents) |
|
34 |
|
35 def package(self): return self.package_ |
|
36 |
|
37 def set_package(self, x): |
|
38 self.has_package_ = 1 |
|
39 self.package_ = x |
|
40 |
|
41 def clear_package(self): |
|
42 self.has_package_ = 0 |
|
43 self.package_ = "" |
|
44 |
|
45 def has_package(self): return self.has_package_ |
|
46 |
|
47 def capability_size(self): return len(self.capability_) |
|
48 def capability_list(self): return self.capability_ |
|
49 |
|
50 def capability(self, i): |
|
51 return self.capability_[i] |
|
52 |
|
53 def set_capability(self, i, x): |
|
54 self.capability_[i] = x |
|
55 |
|
56 def add_capability(self, x): |
|
57 self.capability_.append(x) |
|
58 |
|
59 def clear_capability(self): |
|
60 self.capability_ = [] |
|
61 |
|
62 def call_size(self): return len(self.call_) |
|
63 def call_list(self): return self.call_ |
|
64 |
|
65 def call(self, i): |
|
66 return self.call_[i] |
|
67 |
|
68 def set_call(self, i, x): |
|
69 self.call_[i] = x |
|
70 |
|
71 def add_call(self, x): |
|
72 self.call_.append(x) |
|
73 |
|
74 def clear_call(self): |
|
75 self.call_ = [] |
|
76 |
|
77 |
|
78 def MergeFrom(self, x): |
|
79 assert x is not self |
|
80 if (x.has_package()): self.set_package(x.package()) |
|
81 for i in xrange(x.capability_size()): self.add_capability(x.capability(i)) |
|
82 for i in xrange(x.call_size()): self.add_call(x.call(i)) |
|
83 |
|
84 def Equals(self, x): |
|
85 if x is self: return 1 |
|
86 if self.has_package_ != x.has_package_: return 0 |
|
87 if self.has_package_ and self.package_ != x.package_: return 0 |
|
88 if len(self.capability_) != len(x.capability_): return 0 |
|
89 for e1, e2 in zip(self.capability_, x.capability_): |
|
90 if e1 != e2: return 0 |
|
91 if len(self.call_) != len(x.call_): return 0 |
|
92 for e1, e2 in zip(self.call_, x.call_): |
|
93 if e1 != e2: return 0 |
|
94 return 1 |
|
95 |
|
96 def IsInitialized(self, debug_strs=None): |
|
97 initialized = 1 |
|
98 if (not self.has_package_): |
|
99 initialized = 0 |
|
100 if debug_strs is not None: |
|
101 debug_strs.append('Required field: package not set.') |
|
102 return initialized |
|
103 |
|
104 def ByteSize(self): |
|
105 n = 0 |
|
106 n += self.lengthString(len(self.package_)) |
|
107 n += 1 * len(self.capability_) |
|
108 for i in xrange(len(self.capability_)): n += self.lengthString(len(self.capability_[i])) |
|
109 n += 1 * len(self.call_) |
|
110 for i in xrange(len(self.call_)): n += self.lengthString(len(self.call_[i])) |
|
111 return n + 1 |
|
112 |
|
113 def Clear(self): |
|
114 self.clear_package() |
|
115 self.clear_capability() |
|
116 self.clear_call() |
|
117 |
|
118 def OutputUnchecked(self, out): |
|
119 out.putVarInt32(10) |
|
120 out.putPrefixedString(self.package_) |
|
121 for i in xrange(len(self.capability_)): |
|
122 out.putVarInt32(18) |
|
123 out.putPrefixedString(self.capability_[i]) |
|
124 for i in xrange(len(self.call_)): |
|
125 out.putVarInt32(26) |
|
126 out.putPrefixedString(self.call_[i]) |
|
127 |
|
128 def TryMerge(self, d): |
|
129 while d.avail() > 0: |
|
130 tt = d.getVarInt32() |
|
131 if tt == 10: |
|
132 self.set_package(d.getPrefixedString()) |
|
133 continue |
|
134 if tt == 18: |
|
135 self.add_capability(d.getPrefixedString()) |
|
136 continue |
|
137 if tt == 26: |
|
138 self.add_call(d.getPrefixedString()) |
|
139 continue |
|
140 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
141 d.skipData(tt) |
|
142 |
|
143 |
|
144 def __str__(self, prefix="", printElemNumber=0): |
|
145 res="" |
|
146 if self.has_package_: res+=prefix+("package: %s\n" % self.DebugFormatString(self.package_)) |
|
147 cnt=0 |
|
148 for e in self.capability_: |
|
149 elm="" |
|
150 if printElemNumber: elm="(%d)" % cnt |
|
151 res+=prefix+("capability%s: %s\n" % (elm, self.DebugFormatString(e))) |
|
152 cnt+=1 |
|
153 cnt=0 |
|
154 for e in self.call_: |
|
155 elm="" |
|
156 if printElemNumber: elm="(%d)" % cnt |
|
157 res+=prefix+("call%s: %s\n" % (elm, self.DebugFormatString(e))) |
|
158 cnt+=1 |
|
159 return res |
|
160 |
|
161 kpackage = 1 |
|
162 kcapability = 2 |
|
163 kcall = 3 |
|
164 |
|
165 _TEXT = ( |
|
166 "ErrorCode", |
|
167 "package", |
|
168 "capability", |
|
169 "call", |
|
170 ) |
|
171 |
|
172 _TYPES = ( |
|
173 ProtocolBuffer.Encoder.NUMERIC, |
|
174 ProtocolBuffer.Encoder.STRING, |
|
175 |
|
176 ProtocolBuffer.Encoder.STRING, |
|
177 |
|
178 ProtocolBuffer.Encoder.STRING, |
|
179 |
|
180 ) |
|
181 |
|
182 _STYLE = """""" |
|
183 _STYLE_CONTENT_TYPE = """""" |
|
184 class IsEnabledResponse(ProtocolBuffer.ProtocolMessage): |
|
185 |
|
186 ENABLED = 1 |
|
187 SCHEDULED_FUTURE = 2 |
|
188 SCHEDULED_NOW = 3 |
|
189 DISABLED = 4 |
|
190 UNKNOWN = 5 |
|
191 |
|
192 _SummaryStatus_NAMES = { |
|
193 1: "ENABLED", |
|
194 2: "SCHEDULED_FUTURE", |
|
195 3: "SCHEDULED_NOW", |
|
196 4: "DISABLED", |
|
197 5: "UNKNOWN", |
|
198 } |
|
199 |
|
200 def SummaryStatus_Name(cls, x): return cls._SummaryStatus_NAMES.get(x, "") |
|
201 SummaryStatus_Name = classmethod(SummaryStatus_Name) |
|
202 |
|
203 has_summary_status_ = 0 |
|
204 summary_status_ = 0 |
|
205 has_time_until_scheduled_ = 0 |
|
206 time_until_scheduled_ = 0 |
|
207 |
|
208 def __init__(self, contents=None): |
|
209 self.config_ = [] |
|
210 if contents is not None: self.MergeFromString(contents) |
|
211 |
|
212 def summary_status(self): return self.summary_status_ |
|
213 |
|
214 def set_summary_status(self, x): |
|
215 self.has_summary_status_ = 1 |
|
216 self.summary_status_ = x |
|
217 |
|
218 def clear_summary_status(self): |
|
219 self.has_summary_status_ = 0 |
|
220 self.summary_status_ = 0 |
|
221 |
|
222 def has_summary_status(self): return self.has_summary_status_ |
|
223 |
|
224 def time_until_scheduled(self): return self.time_until_scheduled_ |
|
225 |
|
226 def set_time_until_scheduled(self, x): |
|
227 self.has_time_until_scheduled_ = 1 |
|
228 self.time_until_scheduled_ = x |
|
229 |
|
230 def clear_time_until_scheduled(self): |
|
231 self.has_time_until_scheduled_ = 0 |
|
232 self.time_until_scheduled_ = 0 |
|
233 |
|
234 def has_time_until_scheduled(self): return self.has_time_until_scheduled_ |
|
235 |
|
236 def config_size(self): return len(self.config_) |
|
237 def config_list(self): return self.config_ |
|
238 |
|
239 def config(self, i): |
|
240 return self.config_[i] |
|
241 |
|
242 def mutable_config(self, i): |
|
243 return self.config_[i] |
|
244 |
|
245 def add_config(self): |
|
246 x = CapabilityConfig() |
|
247 self.config_.append(x) |
|
248 return x |
|
249 |
|
250 def clear_config(self): |
|
251 self.config_ = [] |
|
252 |
|
253 def MergeFrom(self, x): |
|
254 assert x is not self |
|
255 if (x.has_summary_status()): self.set_summary_status(x.summary_status()) |
|
256 if (x.has_time_until_scheduled()): self.set_time_until_scheduled(x.time_until_scheduled()) |
|
257 for i in xrange(x.config_size()): self.add_config().CopyFrom(x.config(i)) |
|
258 |
|
259 def Equals(self, x): |
|
260 if x is self: return 1 |
|
261 if self.has_summary_status_ != x.has_summary_status_: return 0 |
|
262 if self.has_summary_status_ and self.summary_status_ != x.summary_status_: return 0 |
|
263 if self.has_time_until_scheduled_ != x.has_time_until_scheduled_: return 0 |
|
264 if self.has_time_until_scheduled_ and self.time_until_scheduled_ != x.time_until_scheduled_: return 0 |
|
265 if len(self.config_) != len(x.config_): return 0 |
|
266 for e1, e2 in zip(self.config_, x.config_): |
|
267 if e1 != e2: return 0 |
|
268 return 1 |
|
269 |
|
270 def IsInitialized(self, debug_strs=None): |
|
271 initialized = 1 |
|
272 if (not self.has_summary_status_): |
|
273 initialized = 0 |
|
274 if debug_strs is not None: |
|
275 debug_strs.append('Required field: summary_status not set.') |
|
276 for p in self.config_: |
|
277 if not p.IsInitialized(debug_strs): initialized=0 |
|
278 return initialized |
|
279 |
|
280 def ByteSize(self): |
|
281 n = 0 |
|
282 n += self.lengthVarInt64(self.summary_status_) |
|
283 if (self.has_time_until_scheduled_): n += 1 + self.lengthVarInt64(self.time_until_scheduled_) |
|
284 n += 1 * len(self.config_) |
|
285 for i in xrange(len(self.config_)): n += self.lengthString(self.config_[i].ByteSize()) |
|
286 return n + 1 |
|
287 |
|
288 def Clear(self): |
|
289 self.clear_summary_status() |
|
290 self.clear_time_until_scheduled() |
|
291 self.clear_config() |
|
292 |
|
293 def OutputUnchecked(self, out): |
|
294 out.putVarInt32(8) |
|
295 out.putVarInt32(self.summary_status_) |
|
296 if (self.has_time_until_scheduled_): |
|
297 out.putVarInt32(16) |
|
298 out.putVarInt64(self.time_until_scheduled_) |
|
299 for i in xrange(len(self.config_)): |
|
300 out.putVarInt32(26) |
|
301 out.putVarInt32(self.config_[i].ByteSize()) |
|
302 self.config_[i].OutputUnchecked(out) |
|
303 |
|
304 def TryMerge(self, d): |
|
305 while d.avail() > 0: |
|
306 tt = d.getVarInt32() |
|
307 if tt == 8: |
|
308 self.set_summary_status(d.getVarInt32()) |
|
309 continue |
|
310 if tt == 16: |
|
311 self.set_time_until_scheduled(d.getVarInt64()) |
|
312 continue |
|
313 if tt == 26: |
|
314 length = d.getVarInt32() |
|
315 tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
|
316 d.skip(length) |
|
317 self.add_config().TryMerge(tmp) |
|
318 continue |
|
319 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
320 d.skipData(tt) |
|
321 |
|
322 |
|
323 def __str__(self, prefix="", printElemNumber=0): |
|
324 res="" |
|
325 if self.has_summary_status_: res+=prefix+("summary_status: %s\n" % self.DebugFormatInt32(self.summary_status_)) |
|
326 if self.has_time_until_scheduled_: res+=prefix+("time_until_scheduled: %s\n" % self.DebugFormatInt64(self.time_until_scheduled_)) |
|
327 cnt=0 |
|
328 for e in self.config_: |
|
329 elm="" |
|
330 if printElemNumber: elm="(%d)" % cnt |
|
331 res+=prefix+("config%s <\n" % elm) |
|
332 res+=e.__str__(prefix + " ", printElemNumber) |
|
333 res+=prefix+">\n" |
|
334 cnt+=1 |
|
335 return res |
|
336 |
|
337 ksummary_status = 1 |
|
338 ktime_until_scheduled = 2 |
|
339 kconfig = 3 |
|
340 |
|
341 _TEXT = ( |
|
342 "ErrorCode", |
|
343 "summary_status", |
|
344 "time_until_scheduled", |
|
345 "config", |
|
346 ) |
|
347 |
|
348 _TYPES = ( |
|
349 ProtocolBuffer.Encoder.NUMERIC, |
|
350 ProtocolBuffer.Encoder.NUMERIC, |
|
351 |
|
352 ProtocolBuffer.Encoder.NUMERIC, |
|
353 |
|
354 ProtocolBuffer.Encoder.STRING, |
|
355 |
|
356 ) |
|
357 |
|
358 _STYLE = """""" |
|
359 _STYLE_CONTENT_TYPE = """""" |
|
360 |
|
361 __all__ = ['IsEnabledRequest','IsEnabledResponse'] |