]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
1 | /* |
2 | * Licensed to the Apache Software Foundation (ASF) under one | |
3 | * or more contributor license agreements. See the NOTICE file | |
4 | * distributed with this work for additional information | |
5 | * regarding copyright ownership. The ASF licenses this file | |
6 | * to you under the Apache License, Version 2.0 (the | |
7 | * "License"); you may not use this file except in compliance | |
8 | * with the License. You may obtain a copy of the License at | |
9 | * | |
10 | * http://www.apache.org/licenses/LICENSE-2.0 | |
11 | * | |
12 | * Unless required by applicable law or agreed to in writing, | |
13 | * software distributed under the License is distributed on an | |
14 | * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
15 | * KIND, either express or implied. See the License for the | |
16 | * specific language governing permissions and limitations | |
17 | * under the License. | |
18 | */ | |
19 | ||
20 | package thrift | |
21 | ||
22 | // Autogenerated by Thrift Compiler (FIXME) | |
23 | // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING | |
24 | ||
25 | /* THE FOLLOWING THRIFT FILE WAS USED TO CREATE THIS | |
26 | ||
27 | enum MyTestEnum { | |
28 | FIRST = 1, | |
29 | SECOND = 2, | |
30 | THIRD = 3, | |
31 | FOURTH = 4, | |
32 | } | |
33 | ||
34 | struct MyTestStruct { | |
35 | 1: bool on, | |
36 | 2: byte b, | |
37 | 3: i16 int16, | |
38 | 4: i32 int32, | |
39 | 5: i64 int64, | |
40 | 6: double d, | |
41 | 7: string st, | |
42 | 8: binary bin, | |
43 | 9: map<string, string> stringMap, | |
44 | 10: list<string> stringList, | |
45 | 11: set<string> stringSet, | |
46 | 12: MyTestEnum e, | |
47 | } | |
48 | */ | |
49 | ||
50 | import ( | |
51 | "fmt" | |
52 | ) | |
53 | ||
54 | // (needed to ensure safety because of naive import list construction.) | |
55 | var _ = ZERO | |
56 | var _ = fmt.Printf | |
57 | ||
58 | var GoUnusedProtection__ int | |
59 | ||
60 | type MyTestEnum int64 | |
61 | ||
62 | const ( | |
63 | MyTestEnum_FIRST MyTestEnum = 1 | |
64 | MyTestEnum_SECOND MyTestEnum = 2 | |
65 | MyTestEnum_THIRD MyTestEnum = 3 | |
66 | MyTestEnum_FOURTH MyTestEnum = 4 | |
67 | ) | |
68 | ||
69 | func (p MyTestEnum) String() string { | |
70 | switch p { | |
71 | case MyTestEnum_FIRST: | |
72 | return "FIRST" | |
73 | case MyTestEnum_SECOND: | |
74 | return "SECOND" | |
75 | case MyTestEnum_THIRD: | |
76 | return "THIRD" | |
77 | case MyTestEnum_FOURTH: | |
78 | return "FOURTH" | |
79 | } | |
80 | return "<UNSET>" | |
81 | } | |
82 | ||
83 | func MyTestEnumFromString(s string) (MyTestEnum, error) { | |
84 | switch s { | |
85 | case "FIRST": | |
86 | return MyTestEnum_FIRST, nil | |
87 | case "SECOND": | |
88 | return MyTestEnum_SECOND, nil | |
89 | case "THIRD": | |
90 | return MyTestEnum_THIRD, nil | |
91 | case "FOURTH": | |
92 | return MyTestEnum_FOURTH, nil | |
93 | } | |
94 | return MyTestEnum(0), fmt.Errorf("not a valid MyTestEnum string") | |
95 | } | |
96 | ||
97 | func MyTestEnumPtr(v MyTestEnum) *MyTestEnum { return &v } | |
98 | ||
99 | type MyTestStruct struct { | |
100 | On bool `thrift:"on,1" json:"on"` | |
101 | B int8 `thrift:"b,2" json:"b"` | |
102 | Int16 int16 `thrift:"int16,3" json:"int16"` | |
103 | Int32 int32 `thrift:"int32,4" json:"int32"` | |
104 | Int64 int64 `thrift:"int64,5" json:"int64"` | |
105 | D float64 `thrift:"d,6" json:"d"` | |
106 | St string `thrift:"st,7" json:"st"` | |
107 | Bin []byte `thrift:"bin,8" json:"bin"` | |
108 | StringMap map[string]string `thrift:"stringMap,9" json:"stringMap"` | |
109 | StringList []string `thrift:"stringList,10" json:"stringList"` | |
110 | StringSet map[string]struct{} `thrift:"stringSet,11" json:"stringSet"` | |
111 | E MyTestEnum `thrift:"e,12" json:"e"` | |
112 | } | |
113 | ||
114 | func NewMyTestStruct() *MyTestStruct { | |
115 | return &MyTestStruct{} | |
116 | } | |
117 | ||
118 | func (p *MyTestStruct) GetOn() bool { | |
119 | return p.On | |
120 | } | |
121 | ||
122 | func (p *MyTestStruct) GetB() int8 { | |
123 | return p.B | |
124 | } | |
125 | ||
126 | func (p *MyTestStruct) GetInt16() int16 { | |
127 | return p.Int16 | |
128 | } | |
129 | ||
130 | func (p *MyTestStruct) GetInt32() int32 { | |
131 | return p.Int32 | |
132 | } | |
133 | ||
134 | func (p *MyTestStruct) GetInt64() int64 { | |
135 | return p.Int64 | |
136 | } | |
137 | ||
138 | func (p *MyTestStruct) GetD() float64 { | |
139 | return p.D | |
140 | } | |
141 | ||
142 | func (p *MyTestStruct) GetSt() string { | |
143 | return p.St | |
144 | } | |
145 | ||
146 | func (p *MyTestStruct) GetBin() []byte { | |
147 | return p.Bin | |
148 | } | |
149 | ||
150 | func (p *MyTestStruct) GetStringMap() map[string]string { | |
151 | return p.StringMap | |
152 | } | |
153 | ||
154 | func (p *MyTestStruct) GetStringList() []string { | |
155 | return p.StringList | |
156 | } | |
157 | ||
158 | func (p *MyTestStruct) GetStringSet() map[string]struct{} { | |
159 | return p.StringSet | |
160 | } | |
161 | ||
162 | func (p *MyTestStruct) GetE() MyTestEnum { | |
163 | return p.E | |
164 | } | |
165 | func (p *MyTestStruct) Read(iprot TProtocol) error { | |
166 | if _, err := iprot.ReadStructBegin(); err != nil { | |
167 | return PrependError(fmt.Sprintf("%T read error: ", p), err) | |
168 | } | |
169 | for { | |
170 | _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() | |
171 | if err != nil { | |
172 | return PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) | |
173 | } | |
174 | if fieldTypeId == STOP { | |
175 | break | |
176 | } | |
177 | switch fieldId { | |
178 | case 1: | |
179 | if err := p.readField1(iprot); err != nil { | |
180 | return err | |
181 | } | |
182 | case 2: | |
183 | if err := p.readField2(iprot); err != nil { | |
184 | return err | |
185 | } | |
186 | case 3: | |
187 | if err := p.readField3(iprot); err != nil { | |
188 | return err | |
189 | } | |
190 | case 4: | |
191 | if err := p.readField4(iprot); err != nil { | |
192 | return err | |
193 | } | |
194 | case 5: | |
195 | if err := p.readField5(iprot); err != nil { | |
196 | return err | |
197 | } | |
198 | case 6: | |
199 | if err := p.readField6(iprot); err != nil { | |
200 | return err | |
201 | } | |
202 | case 7: | |
203 | if err := p.readField7(iprot); err != nil { | |
204 | return err | |
205 | } | |
206 | case 8: | |
207 | if err := p.readField8(iprot); err != nil { | |
208 | return err | |
209 | } | |
210 | case 9: | |
211 | if err := p.readField9(iprot); err != nil { | |
212 | return err | |
213 | } | |
214 | case 10: | |
215 | if err := p.readField10(iprot); err != nil { | |
216 | return err | |
217 | } | |
218 | case 11: | |
219 | if err := p.readField11(iprot); err != nil { | |
220 | return err | |
221 | } | |
222 | case 12: | |
223 | if err := p.readField12(iprot); err != nil { | |
224 | return err | |
225 | } | |
226 | default: | |
227 | if err := iprot.Skip(fieldTypeId); err != nil { | |
228 | return err | |
229 | } | |
230 | } | |
231 | if err := iprot.ReadFieldEnd(); err != nil { | |
232 | return err | |
233 | } | |
234 | } | |
235 | if err := iprot.ReadStructEnd(); err != nil { | |
236 | return PrependError(fmt.Sprintf("%T read struct end error: ", p), err) | |
237 | } | |
238 | return nil | |
239 | } | |
240 | ||
241 | func (p *MyTestStruct) readField1(iprot TProtocol) error { | |
242 | if v, err := iprot.ReadBool(); err != nil { | |
243 | return PrependError("error reading field 1: ", err) | |
244 | } else { | |
245 | p.On = v | |
246 | } | |
247 | return nil | |
248 | } | |
249 | ||
250 | func (p *MyTestStruct) readField2(iprot TProtocol) error { | |
251 | if v, err := iprot.ReadByte(); err != nil { | |
252 | return PrependError("error reading field 2: ", err) | |
253 | } else { | |
254 | temp := int8(v) | |
255 | p.B = temp | |
256 | } | |
257 | return nil | |
258 | } | |
259 | ||
260 | func (p *MyTestStruct) readField3(iprot TProtocol) error { | |
261 | if v, err := iprot.ReadI16(); err != nil { | |
262 | return PrependError("error reading field 3: ", err) | |
263 | } else { | |
264 | p.Int16 = v | |
265 | } | |
266 | return nil | |
267 | } | |
268 | ||
269 | func (p *MyTestStruct) readField4(iprot TProtocol) error { | |
270 | if v, err := iprot.ReadI32(); err != nil { | |
271 | return PrependError("error reading field 4: ", err) | |
272 | } else { | |
273 | p.Int32 = v | |
274 | } | |
275 | return nil | |
276 | } | |
277 | ||
278 | func (p *MyTestStruct) readField5(iprot TProtocol) error { | |
279 | if v, err := iprot.ReadI64(); err != nil { | |
280 | return PrependError("error reading field 5: ", err) | |
281 | } else { | |
282 | p.Int64 = v | |
283 | } | |
284 | return nil | |
285 | } | |
286 | ||
287 | func (p *MyTestStruct) readField6(iprot TProtocol) error { | |
288 | if v, err := iprot.ReadDouble(); err != nil { | |
289 | return PrependError("error reading field 6: ", err) | |
290 | } else { | |
291 | p.D = v | |
292 | } | |
293 | return nil | |
294 | } | |
295 | ||
296 | func (p *MyTestStruct) readField7(iprot TProtocol) error { | |
297 | if v, err := iprot.ReadString(); err != nil { | |
298 | return PrependError("error reading field 7: ", err) | |
299 | } else { | |
300 | p.St = v | |
301 | } | |
302 | return nil | |
303 | } | |
304 | ||
305 | func (p *MyTestStruct) readField8(iprot TProtocol) error { | |
306 | if v, err := iprot.ReadBinary(); err != nil { | |
307 | return PrependError("error reading field 8: ", err) | |
308 | } else { | |
309 | p.Bin = v | |
310 | } | |
311 | return nil | |
312 | } | |
313 | ||
314 | func (p *MyTestStruct) readField9(iprot TProtocol) error { | |
315 | _, _, size, err := iprot.ReadMapBegin() | |
316 | if err != nil { | |
317 | return PrependError("error reading map begin: ", err) | |
318 | } | |
319 | tMap := make(map[string]string, size) | |
320 | p.StringMap = tMap | |
321 | for i := 0; i < size; i++ { | |
322 | var _key0 string | |
323 | if v, err := iprot.ReadString(); err != nil { | |
324 | return PrependError("error reading field 0: ", err) | |
325 | } else { | |
326 | _key0 = v | |
327 | } | |
328 | var _val1 string | |
329 | if v, err := iprot.ReadString(); err != nil { | |
330 | return PrependError("error reading field 0: ", err) | |
331 | } else { | |
332 | _val1 = v | |
333 | } | |
334 | p.StringMap[_key0] = _val1 | |
335 | } | |
336 | if err := iprot.ReadMapEnd(); err != nil { | |
337 | return PrependError("error reading map end: ", err) | |
338 | } | |
339 | return nil | |
340 | } | |
341 | ||
342 | func (p *MyTestStruct) readField10(iprot TProtocol) error { | |
343 | _, size, err := iprot.ReadListBegin() | |
344 | if err != nil { | |
345 | return PrependError("error reading list begin: ", err) | |
346 | } | |
347 | tSlice := make([]string, 0, size) | |
348 | p.StringList = tSlice | |
349 | for i := 0; i < size; i++ { | |
350 | var _elem2 string | |
351 | if v, err := iprot.ReadString(); err != nil { | |
352 | return PrependError("error reading field 0: ", err) | |
353 | } else { | |
354 | _elem2 = v | |
355 | } | |
356 | p.StringList = append(p.StringList, _elem2) | |
357 | } | |
358 | if err := iprot.ReadListEnd(); err != nil { | |
359 | return PrependError("error reading list end: ", err) | |
360 | } | |
361 | return nil | |
362 | } | |
363 | ||
364 | func (p *MyTestStruct) readField11(iprot TProtocol) error { | |
365 | _, size, err := iprot.ReadSetBegin() | |
366 | if err != nil { | |
367 | return PrependError("error reading set begin: ", err) | |
368 | } | |
369 | tSet := make(map[string]struct{}, size) | |
370 | p.StringSet = tSet | |
371 | for i := 0; i < size; i++ { | |
372 | var _elem3 string | |
373 | if v, err := iprot.ReadString(); err != nil { | |
374 | return PrependError("error reading field 0: ", err) | |
375 | } else { | |
376 | _elem3 = v | |
377 | } | |
378 | p.StringSet[_elem3] = struct{}{} | |
379 | } | |
380 | if err := iprot.ReadSetEnd(); err != nil { | |
381 | return PrependError("error reading set end: ", err) | |
382 | } | |
383 | return nil | |
384 | } | |
385 | ||
386 | func (p *MyTestStruct) readField12(iprot TProtocol) error { | |
387 | if v, err := iprot.ReadI32(); err != nil { | |
388 | return PrependError("error reading field 12: ", err) | |
389 | } else { | |
390 | temp := MyTestEnum(v) | |
391 | p.E = temp | |
392 | } | |
393 | return nil | |
394 | } | |
395 | ||
396 | func (p *MyTestStruct) Write(oprot TProtocol) error { | |
397 | if err := oprot.WriteStructBegin("MyTestStruct"); err != nil { | |
398 | return PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) | |
399 | } | |
400 | if err := p.writeField1(oprot); err != nil { | |
401 | return err | |
402 | } | |
403 | if err := p.writeField2(oprot); err != nil { | |
404 | return err | |
405 | } | |
406 | if err := p.writeField3(oprot); err != nil { | |
407 | return err | |
408 | } | |
409 | if err := p.writeField4(oprot); err != nil { | |
410 | return err | |
411 | } | |
412 | if err := p.writeField5(oprot); err != nil { | |
413 | return err | |
414 | } | |
415 | if err := p.writeField6(oprot); err != nil { | |
416 | return err | |
417 | } | |
418 | if err := p.writeField7(oprot); err != nil { | |
419 | return err | |
420 | } | |
421 | if err := p.writeField8(oprot); err != nil { | |
422 | return err | |
423 | } | |
424 | if err := p.writeField9(oprot); err != nil { | |
425 | return err | |
426 | } | |
427 | if err := p.writeField10(oprot); err != nil { | |
428 | return err | |
429 | } | |
430 | if err := p.writeField11(oprot); err != nil { | |
431 | return err | |
432 | } | |
433 | if err := p.writeField12(oprot); err != nil { | |
434 | return err | |
435 | } | |
436 | if err := oprot.WriteFieldStop(); err != nil { | |
437 | return PrependError("write field stop error: ", err) | |
438 | } | |
439 | if err := oprot.WriteStructEnd(); err != nil { | |
440 | return PrependError("write struct stop error: ", err) | |
441 | } | |
442 | return nil | |
443 | } | |
444 | ||
445 | func (p *MyTestStruct) writeField1(oprot TProtocol) (err error) { | |
446 | if err := oprot.WriteFieldBegin("on", BOOL, 1); err != nil { | |
447 | return PrependError(fmt.Sprintf("%T write field begin error 1:on: ", p), err) | |
448 | } | |
449 | if err := oprot.WriteBool(bool(p.On)); err != nil { | |
450 | return PrependError(fmt.Sprintf("%T.on (1) field write error: ", p), err) | |
451 | } | |
452 | if err := oprot.WriteFieldEnd(); err != nil { | |
453 | return PrependError(fmt.Sprintf("%T write field end error 1:on: ", p), err) | |
454 | } | |
455 | return err | |
456 | } | |
457 | ||
458 | func (p *MyTestStruct) writeField2(oprot TProtocol) (err error) { | |
459 | if err := oprot.WriteFieldBegin("b", BYTE, 2); err != nil { | |
460 | return PrependError(fmt.Sprintf("%T write field begin error 2:b: ", p), err) | |
461 | } | |
462 | if err := oprot.WriteByte(int8(p.B)); err != nil { | |
463 | return PrependError(fmt.Sprintf("%T.b (2) field write error: ", p), err) | |
464 | } | |
465 | if err := oprot.WriteFieldEnd(); err != nil { | |
466 | return PrependError(fmt.Sprintf("%T write field end error 2:b: ", p), err) | |
467 | } | |
468 | return err | |
469 | } | |
470 | ||
471 | func (p *MyTestStruct) writeField3(oprot TProtocol) (err error) { | |
472 | if err := oprot.WriteFieldBegin("int16", I16, 3); err != nil { | |
473 | return PrependError(fmt.Sprintf("%T write field begin error 3:int16: ", p), err) | |
474 | } | |
475 | if err := oprot.WriteI16(int16(p.Int16)); err != nil { | |
476 | return PrependError(fmt.Sprintf("%T.int16 (3) field write error: ", p), err) | |
477 | } | |
478 | if err := oprot.WriteFieldEnd(); err != nil { | |
479 | return PrependError(fmt.Sprintf("%T write field end error 3:int16: ", p), err) | |
480 | } | |
481 | return err | |
482 | } | |
483 | ||
484 | func (p *MyTestStruct) writeField4(oprot TProtocol) (err error) { | |
485 | if err := oprot.WriteFieldBegin("int32", I32, 4); err != nil { | |
486 | return PrependError(fmt.Sprintf("%T write field begin error 4:int32: ", p), err) | |
487 | } | |
488 | if err := oprot.WriteI32(int32(p.Int32)); err != nil { | |
489 | return PrependError(fmt.Sprintf("%T.int32 (4) field write error: ", p), err) | |
490 | } | |
491 | if err := oprot.WriteFieldEnd(); err != nil { | |
492 | return PrependError(fmt.Sprintf("%T write field end error 4:int32: ", p), err) | |
493 | } | |
494 | return err | |
495 | } | |
496 | ||
497 | func (p *MyTestStruct) writeField5(oprot TProtocol) (err error) { | |
498 | if err := oprot.WriteFieldBegin("int64", I64, 5); err != nil { | |
499 | return PrependError(fmt.Sprintf("%T write field begin error 5:int64: ", p), err) | |
500 | } | |
501 | if err := oprot.WriteI64(int64(p.Int64)); err != nil { | |
502 | return PrependError(fmt.Sprintf("%T.int64 (5) field write error: ", p), err) | |
503 | } | |
504 | if err := oprot.WriteFieldEnd(); err != nil { | |
505 | return PrependError(fmt.Sprintf("%T write field end error 5:int64: ", p), err) | |
506 | } | |
507 | return err | |
508 | } | |
509 | ||
510 | func (p *MyTestStruct) writeField6(oprot TProtocol) (err error) { | |
511 | if err := oprot.WriteFieldBegin("d", DOUBLE, 6); err != nil { | |
512 | return PrependError(fmt.Sprintf("%T write field begin error 6:d: ", p), err) | |
513 | } | |
514 | if err := oprot.WriteDouble(float64(p.D)); err != nil { | |
515 | return PrependError(fmt.Sprintf("%T.d (6) field write error: ", p), err) | |
516 | } | |
517 | if err := oprot.WriteFieldEnd(); err != nil { | |
518 | return PrependError(fmt.Sprintf("%T write field end error 6:d: ", p), err) | |
519 | } | |
520 | return err | |
521 | } | |
522 | ||
523 | func (p *MyTestStruct) writeField7(oprot TProtocol) (err error) { | |
524 | if err := oprot.WriteFieldBegin("st", STRING, 7); err != nil { | |
525 | return PrependError(fmt.Sprintf("%T write field begin error 7:st: ", p), err) | |
526 | } | |
527 | if err := oprot.WriteString(string(p.St)); err != nil { | |
528 | return PrependError(fmt.Sprintf("%T.st (7) field write error: ", p), err) | |
529 | } | |
530 | if err := oprot.WriteFieldEnd(); err != nil { | |
531 | return PrependError(fmt.Sprintf("%T write field end error 7:st: ", p), err) | |
532 | } | |
533 | return err | |
534 | } | |
535 | ||
536 | func (p *MyTestStruct) writeField8(oprot TProtocol) (err error) { | |
537 | if err := oprot.WriteFieldBegin("bin", STRING, 8); err != nil { | |
538 | return PrependError(fmt.Sprintf("%T write field begin error 8:bin: ", p), err) | |
539 | } | |
540 | if err := oprot.WriteBinary(p.Bin); err != nil { | |
541 | return PrependError(fmt.Sprintf("%T.bin (8) field write error: ", p), err) | |
542 | } | |
543 | if err := oprot.WriteFieldEnd(); err != nil { | |
544 | return PrependError(fmt.Sprintf("%T write field end error 8:bin: ", p), err) | |
545 | } | |
546 | return err | |
547 | } | |
548 | ||
549 | func (p *MyTestStruct) writeField9(oprot TProtocol) (err error) { | |
550 | if err := oprot.WriteFieldBegin("stringMap", MAP, 9); err != nil { | |
551 | return PrependError(fmt.Sprintf("%T write field begin error 9:stringMap: ", p), err) | |
552 | } | |
553 | if err := oprot.WriteMapBegin(STRING, STRING, len(p.StringMap)); err != nil { | |
554 | return PrependError("error writing map begin: ", err) | |
555 | } | |
556 | for k, v := range p.StringMap { | |
557 | if err := oprot.WriteString(string(k)); err != nil { | |
558 | return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) | |
559 | } | |
560 | if err := oprot.WriteString(string(v)); err != nil { | |
561 | return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) | |
562 | } | |
563 | } | |
564 | if err := oprot.WriteMapEnd(); err != nil { | |
565 | return PrependError("error writing map end: ", err) | |
566 | } | |
567 | if err := oprot.WriteFieldEnd(); err != nil { | |
568 | return PrependError(fmt.Sprintf("%T write field end error 9:stringMap: ", p), err) | |
569 | } | |
570 | return err | |
571 | } | |
572 | ||
573 | func (p *MyTestStruct) writeField10(oprot TProtocol) (err error) { | |
574 | if err := oprot.WriteFieldBegin("stringList", LIST, 10); err != nil { | |
575 | return PrependError(fmt.Sprintf("%T write field begin error 10:stringList: ", p), err) | |
576 | } | |
577 | if err := oprot.WriteListBegin(STRING, len(p.StringList)); err != nil { | |
578 | return PrependError("error writing list begin: ", err) | |
579 | } | |
580 | for _, v := range p.StringList { | |
581 | if err := oprot.WriteString(string(v)); err != nil { | |
582 | return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) | |
583 | } | |
584 | } | |
585 | if err := oprot.WriteListEnd(); err != nil { | |
586 | return PrependError("error writing list end: ", err) | |
587 | } | |
588 | if err := oprot.WriteFieldEnd(); err != nil { | |
589 | return PrependError(fmt.Sprintf("%T write field end error 10:stringList: ", p), err) | |
590 | } | |
591 | return err | |
592 | } | |
593 | ||
594 | func (p *MyTestStruct) writeField11(oprot TProtocol) (err error) { | |
595 | if err := oprot.WriteFieldBegin("stringSet", SET, 11); err != nil { | |
596 | return PrependError(fmt.Sprintf("%T write field begin error 11:stringSet: ", p), err) | |
597 | } | |
598 | if err := oprot.WriteSetBegin(STRING, len(p.StringSet)); err != nil { | |
599 | return PrependError("error writing set begin: ", err) | |
600 | } | |
601 | for v := range p.StringSet { | |
602 | if err := oprot.WriteString(string(v)); err != nil { | |
603 | return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) | |
604 | } | |
605 | } | |
606 | if err := oprot.WriteSetEnd(); err != nil { | |
607 | return PrependError("error writing set end: ", err) | |
608 | } | |
609 | if err := oprot.WriteFieldEnd(); err != nil { | |
610 | return PrependError(fmt.Sprintf("%T write field end error 11:stringSet: ", p), err) | |
611 | } | |
612 | return err | |
613 | } | |
614 | ||
615 | func (p *MyTestStruct) writeField12(oprot TProtocol) (err error) { | |
616 | if err := oprot.WriteFieldBegin("e", I32, 12); err != nil { | |
617 | return PrependError(fmt.Sprintf("%T write field begin error 12:e: ", p), err) | |
618 | } | |
619 | if err := oprot.WriteI32(int32(p.E)); err != nil { | |
620 | return PrependError(fmt.Sprintf("%T.e (12) field write error: ", p), err) | |
621 | } | |
622 | if err := oprot.WriteFieldEnd(); err != nil { | |
623 | return PrependError(fmt.Sprintf("%T write field end error 12:e: ", p), err) | |
624 | } | |
625 | return err | |
626 | } | |
627 | ||
628 | func (p *MyTestStruct) String() string { | |
629 | if p == nil { | |
630 | return "<nil>" | |
631 | } | |
632 | return fmt.Sprintf("MyTestStruct(%+v)", *p) | |
633 | } |