third-party/mcrouter/src/mcrouter/lib/carbon/test/gen/CarbonTestMessages-inl.h

   1 /*
   2  *  Copyright (c) Meta Platforms, Inc. and affiliates.
   3  *
   4  *  This source code is licensed under the MIT license found in the LICENSE
   5  *  file in the root directory of this source tree.
   6  *
   7  */
   8
   9 /*
  10  *  THIS FILE IS AUTOGENERATED. DO NOT MODIFY IT; ALL CHANGES WILL BE LOST IN
  11  *  VAIN.
  12  *
  13  *  @generated
  14  */
  15
  16 namespace carbon {
  17 namespace test {
  18 namespace thrift {
  19
  20 template <class Writer>
  21 void TestRequest::serialize(Writer&& writer) const {
  22   writer.writeStructBegin();
  23   writer.writeField(1 /* field id */, key_ref());
  24   writer.writeField(2 /* field id */, dummy2_ref());
  25   writer.writeField(3 /* field id */, testBool_ref());
  26   writer.writeField(4 /* field id */, testChar_ref());
  27   writer.writeField(5 /* field id */, testInt8_ref());
  28   writer.writeField(6 /* field id */, testInt16_ref());
  29   writer.writeField(7 /* field id */, testInt32_ref());
  30   writer.writeField(8 /* field id */, testInt64_ref());
  31   writer.writeField(9 /* field id */, testUInt8_ref());
  32   writer.writeField(10 /* field id */, testUInt16_ref());
  33   writer.writeField(11 /* field id */, testUInt32_ref());
  34   writer.writeField(12 /* field id */, testUInt64_ref());
  35   writer.writeField(13 /* field id */, testFloat_ref());
  36   writer.writeField(14 /* field id */, testDouble_ref());
  37   writer.writeField(15 /* field id */, testShortString_ref());
  38   writer.writeField(16 /* field id */, testLongString_ref());
  39   writer.writeField(17 /* field id */, testIobuf_ref());
  40   writer.writeField(19 /* field id */, testList_ref());
  41   writer.writeField(20 /* field id */, testOptionalString_ref());
  42   writer.writeField(21 /* field id */, testOptionalIobuf_ref());
  43   writer.writeField(22 /* field id */, dummy22_ref());
  44   writer.writeField(23 /* field id */, dummy23_ref());
  45   writer.writeField(24 /* field id */, testNestedVec_ref());
  46   writer.writeField(25 /* field id */, testUMap_ref());
  47   writer.writeField(26 /* field id */, testMap_ref());
  48   writer.writeField(27 /* field id */, testComplexMap_ref());
  49   writer.writeField(28 /* field id */, testUSet_ref());
  50   writer.writeField(29 /* field id */, testSet_ref());
  51   writer.writeField(30 /* field id */, testOptionalBool_ref());
  52   writer.writeField(31 /* field id */, dummy31_ref());
  53   writer.writeField(32 /* field id */, testIOBufList_ref());
  54   writer.writeField(33 /* field id */, testF14FastMap_ref());
  55   writer.writeField(34 /* field id */, testF14NodeMap_ref());
  56   writer.writeField(35 /* field id */, testF14ValueMap_ref());
  57   writer.writeField(36 /* field id */, testF14VectorMap_ref());
  58   writer.writeField(37 /* field id */, testF14FastSet_ref());
  59   writer.writeField(38 /* field id */, testF14NodeSet_ref());
  60   writer.writeField(39 /* field id */, testF14ValueSet_ref());
  61   writer.writeField(40 /* field id */, testF14VectorSet_ref());
  62   writer.writeField(41 /* field id */, testOptionalKeywordString_ref());
  63   writer.writeField(42 /* field id */, testOptionalKeywordIobuf_ref());
  64   writer.writeField(43 /* field id */, testOptionalKeywordBool_ref());
  65   writer.writeFieldStop();
  66   writer.writeStructEnd();
  67 }
  68
  69 template <class V>
  70 void TestRequest::visitFields(V&& v) {
  71   if (!v.visitField(1, "key", *this->key_ref())) {
  72     return;
  73   }
  74   if (!v.visitField(2, "dummy2", *this->dummy2_ref())) {
  75     return;
  76   }
  77   if (!v.visitField(3, "testBool", *this->testBool_ref())) {
  78     return;
  79   }
  80   if (!v.visitField(4, "testChar", *this->testChar_ref())) {
  81     return;
  82   }
  83   if (!v.visitField(5, "testInt8", *this->testInt8_ref())) {
  84     return;
  85   }
  86   if (!v.visitField(6, "testInt16", *this->testInt16_ref())) {
  87     return;
  88   }
  89   if (!v.visitField(7, "testInt32", *this->testInt32_ref())) {
  90     return;
  91   }
  92   if (!v.visitField(8, "testInt64", *this->testInt64_ref())) {
  93     return;
  94   }
  95   if (!v.visitField(9, "testUInt8", *this->testUInt8_ref())) {
  96     return;
  97   }
  98   if (!v.visitField(10, "testUInt16", *this->testUInt16_ref())) {
  99     return;
 100   }
 101   if (!v.visitField(11, "testUInt32", *this->testUInt32_ref())) {
 102     return;
 103   }
 104   if (!v.visitField(12, "testUInt64", *this->testUInt64_ref())) {
 105     return;
 106   }
 107   if (!v.visitField(13, "testFloat", *this->testFloat_ref())) {
 108     return;
 109   }
 110   if (!v.visitField(14, "testDouble", *this->testDouble_ref())) {
 111     return;
 112   }
 113   if (!v.visitField(15, "testShortString", *this->testShortString_ref())) {
 114     return;
 115   }
 116   if (!v.visitField(16, "testLongString", *this->testLongString_ref())) {
 117     return;
 118   }
 119   if (!v.visitField(17, "testIobuf", *this->testIobuf_ref())) {
 120     return;
 121   }
 122   if (!v.visitField(19, "testList", *this->testList_ref())) {
 123     return;
 124   }
 125   if (!v.visitField(20, "testOptionalString", this->testOptionalString_ref())) {
 126     return;
 127   }
 128   if (!v.visitField(21, "testOptionalIobuf", this->testOptionalIobuf_ref())) {
 129     return;
 130   }
 131   if (!v.visitField(22, "dummy22", *this->dummy22_ref())) {
 132     return;
 133   }
 134   if (!v.visitField(23, "dummy23", *this->dummy23_ref())) {
 135     return;
 136   }
 137   if (!v.visitField(24, "testNestedVec", *this->testNestedVec_ref())) {
 138     return;
 139   }
 140   if (!v.visitField(25, "testUMap", *this->testUMap_ref())) {
 141     return;
 142   }
 143   if (!v.visitField(26, "testMap", *this->testMap_ref())) {
 144     return;
 145   }
 146   if (!v.visitField(27, "testComplexMap", *this->testComplexMap_ref())) {
 147     return;
 148   }
 149   if (!v.visitField(28, "testUSet", *this->testUSet_ref())) {
 150     return;
 151   }
 152   if (!v.visitField(29, "testSet", *this->testSet_ref())) {
 153     return;
 154   }
 155   if (!v.visitField(30, "testOptionalBool", this->testOptionalBool_ref())) {
 156     return;
 157   }
 158   if (!v.visitField(31, "dummy31", *this->dummy31_ref())) {
 159     return;
 160   }
 161   if (!v.visitField(32, "testIOBufList", *this->testIOBufList_ref())) {
 162     return;
 163   }
 164   if (!v.visitField(33, "testF14FastMap", *this->testF14FastMap_ref())) {
 165     return;
 166   }
 167   if (!v.visitField(34, "testF14NodeMap", *this->testF14NodeMap_ref())) {
 168     return;
 169   }
 170   if (!v.visitField(35, "testF14ValueMap", *this->testF14ValueMap_ref())) {
 171     return;
 172   }
 173   if (!v.visitField(36, "testF14VectorMap", *this->testF14VectorMap_ref())) {
 174     return;
 175   }
 176   if (!v.visitField(37, "testF14FastSet", *this->testF14FastSet_ref())) {
 177     return;
 178   }
 179   if (!v.visitField(38, "testF14NodeSet", *this->testF14NodeSet_ref())) {
 180     return;
 181   }
 182   if (!v.visitField(39, "testF14ValueSet", *this->testF14ValueSet_ref())) {
 183     return;
 184   }
 185   if (!v.visitField(40, "testF14VectorSet", *this->testF14VectorSet_ref())) {
 186     return;
 187   }
 188   if (!v.visitField(41, "testOptionalKeywordString", this->testOptionalKeywordString_ref())) {
 189     return;
 190   }
 191   if (!v.visitField(42, "testOptionalKeywordIobuf", this->testOptionalKeywordIobuf_ref())) {
 192     return;
 193   }
 194   if (!v.visitField(43, "testOptionalKeywordBool", this->testOptionalKeywordBool_ref())) {
 195     return;
 196   }
 197 }
 198
 199 template <class V>
 200 void TestRequest::visitFields(V&& v) const {
 201   if (!v.visitField(1, "key", *this->key_ref())) {
 202     return;
 203   }
 204   if (!v.visitField(2, "dummy2", *this->dummy2_ref())) {
 205     return;
 206   }
 207   if (!v.visitField(3, "testBool", *this->testBool_ref())) {
 208     return;
 209   }
 210   if (!v.visitField(4, "testChar", *this->testChar_ref())) {
 211     return;
 212   }
 213   if (!v.visitField(5, "testInt8", *this->testInt8_ref())) {
 214     return;
 215   }
 216   if (!v.visitField(6, "testInt16", *this->testInt16_ref())) {
 217     return;
 218   }
 219   if (!v.visitField(7, "testInt32", *this->testInt32_ref())) {
 220     return;
 221   }
 222   if (!v.visitField(8, "testInt64", *this->testInt64_ref())) {
 223     return;
 224   }
 225   if (!v.visitField(9, "testUInt8", *this->testUInt8_ref())) {
 226     return;
 227   }
 228   if (!v.visitField(10, "testUInt16", *this->testUInt16_ref())) {
 229     return;
 230   }
 231   if (!v.visitField(11, "testUInt32", *this->testUInt32_ref())) {
 232     return;
 233   }
 234   if (!v.visitField(12, "testUInt64", *this->testUInt64_ref())) {
 235     return;
 236   }
 237   if (!v.visitField(13, "testFloat", *this->testFloat_ref())) {
 238     return;
 239   }
 240   if (!v.visitField(14, "testDouble", *this->testDouble_ref())) {
 241     return;
 242   }
 243   if (!v.visitField(15, "testShortString", *this->testShortString_ref())) {
 244     return;
 245   }
 246   if (!v.visitField(16, "testLongString", *this->testLongString_ref())) {
 247     return;
 248   }
 249   if (!v.visitField(17, "testIobuf", *this->testIobuf_ref())) {
 250     return;
 251   }
 252   if (!v.visitField(19, "testList", *this->testList_ref())) {
 253     return;
 254   }
 255   if (!v.visitField(20, "testOptionalString", this->testOptionalString_ref())) {
 256     return;
 257   }
 258   if (!v.visitField(21, "testOptionalIobuf", this->testOptionalIobuf_ref())) {
 259     return;
 260   }
 261   if (!v.visitField(22, "dummy22", *this->dummy22_ref())) {
 262     return;
 263   }
 264   if (!v.visitField(23, "dummy23", *this->dummy23_ref())) {
 265     return;
 266   }
 267   if (!v.visitField(24, "testNestedVec", *this->testNestedVec_ref())) {
 268     return;
 269   }
 270   if (!v.visitField(25, "testUMap", *this->testUMap_ref())) {
 271     return;
 272   }
 273   if (!v.visitField(26, "testMap", *this->testMap_ref())) {
 274     return;
 275   }
 276   if (!v.visitField(27, "testComplexMap", *this->testComplexMap_ref())) {
 277     return;
 278   }
 279   if (!v.visitField(28, "testUSet", *this->testUSet_ref())) {
 280     return;
 281   }
 282   if (!v.visitField(29, "testSet", *this->testSet_ref())) {
 283     return;
 284   }
 285   if (!v.visitField(30, "testOptionalBool", this->testOptionalBool_ref())) {
 286     return;
 287   }
 288   if (!v.visitField(31, "dummy31", *this->dummy31_ref())) {
 289     return;
 290   }
 291   if (!v.visitField(32, "testIOBufList", *this->testIOBufList_ref())) {
 292     return;
 293   }
 294   if (!v.visitField(33, "testF14FastMap", *this->testF14FastMap_ref())) {
 295     return;
 296   }
 297   if (!v.visitField(34, "testF14NodeMap", *this->testF14NodeMap_ref())) {
 298     return;
 299   }
 300   if (!v.visitField(35, "testF14ValueMap", *this->testF14ValueMap_ref())) {
 301     return;
 302   }
 303   if (!v.visitField(36, "testF14VectorMap", *this->testF14VectorMap_ref())) {
 304     return;
 305   }
 306   if (!v.visitField(37, "testF14FastSet", *this->testF14FastSet_ref())) {
 307     return;
 308   }
 309   if (!v.visitField(38, "testF14NodeSet", *this->testF14NodeSet_ref())) {
 310     return;
 311   }
 312   if (!v.visitField(39, "testF14ValueSet", *this->testF14ValueSet_ref())) {
 313     return;
 314   }
 315   if (!v.visitField(40, "testF14VectorSet", *this->testF14VectorSet_ref())) {
 316     return;
 317   }
 318   if (!v.visitField(41, "testOptionalKeywordString", this->testOptionalKeywordString_ref())) {
 319     return;
 320   }
 321   if (!v.visitField(42, "testOptionalKeywordIobuf", this->testOptionalKeywordIobuf_ref())) {
 322     return;
 323   }
 324   if (!v.visitField(43, "testOptionalKeywordBool", this->testOptionalKeywordBool_ref())) {
 325     return;
 326   }
 327 }
 328
 329 template <class Writer>
 330 void TestReply::serialize(Writer&& writer) const {
 331   writer.writeStructBegin();
 332   writer.writeField(1 /* field id */, result_ref());
 333   writer.writeField(2 /* field id */, valInt32_ref());
 334   writer.writeField(3 /* field id */, valInt64_ref());
 335   writer.writeFieldStop();
 336   writer.writeStructEnd();
 337 }
 338
 339 template <class V>
 340 void TestReply::visitFields(V&& v) {
 341   if (!v.visitField(1, "result", *this->result_ref())) {
 342     return;
 343   }
 344   if (!v.visitField(2, "valInt32", *this->valInt32_ref())) {
 345     return;
 346   }
 347   if (!v.visitField(3, "valInt64", *this->valInt64_ref())) {
 348     return;
 349   }
 350 }
 351
 352 template <class V>
 353 void TestReply::visitFields(V&& v) const {
 354   if (!v.visitField(1, "result", *this->result_ref())) {
 355     return;
 356   }
 357   if (!v.visitField(2, "valInt32", *this->valInt32_ref())) {
 358     return;
 359   }
 360   if (!v.visitField(3, "valInt64", *this->valInt64_ref())) {
 361     return;
 362   }
 363 }
 364
 365 template <class Writer>
 366 void TestRequestStringKey::serialize(Writer&& writer) const {
 367   writer.writeStructBegin();
 368   writer.writeField(1 /* field id */, key_ref());
 369   writer.writeFieldStop();
 370   writer.writeStructEnd();
 371 }
 372
 373 template <class V>
 374 void TestRequestStringKey::visitFields(V&& v) {
 375   if (!v.visitField(1, "key", *this->key_ref())) {
 376     return;
 377   }
 378 }
 379
 380 template <class V>
 381 void TestRequestStringKey::visitFields(V&& v) const {
 382   if (!v.visitField(1, "key", *this->key_ref())) {
 383     return;
 384   }
 385 }
 386
 387 template <class Writer>
 388 void TestReplyStringKey::serialize(Writer&& writer) const {
 389   writer.writeStructBegin();
 390   writer.writeField(1 /* field id */, result_ref());
 391   writer.writeFieldStop();
 392   writer.writeStructEnd();
 393 }
 394
 395 template <class V>
 396 void TestReplyStringKey::visitFields(V&& v) {
 397   if (!v.visitField(1, "result", *this->result_ref())) {
 398     return;
 399   }
 400 }
 401
 402 template <class V>
 403 void TestReplyStringKey::visitFields(V&& v) const {
 404   if (!v.visitField(1, "result", *this->result_ref())) {
 405     return;
 406   }
 407 }
 408
 409 template <class Writer>
 410 void TestOptionalBool::serialize(Writer&& writer) const {
 411   writer.writeStructBegin();
 412   writer.writeField(1 /* field id */, optionalBool_ref());
 413   writer.writeFieldStop();
 414   writer.writeStructEnd();
 415 }
 416
 417 template <class V>
 418 void TestOptionalBool::visitFields(V&& v) {
 419   if (!v.visitField(1, "optionalBool", this->optionalBool_ref())) {
 420     return;
 421   }
 422 }
 423
 424 template <class V>
 425 void TestOptionalBool::visitFields(V&& v) const {
 426   if (!v.visitField(1, "optionalBool", this->optionalBool_ref())) {
 427     return;
 428   }
 429 }
 430
 431 template <class Writer>
 432 void TestUnion::serialize(Writer&& writer) const {
 433   writer.writeStructBegin();
 434   switch (getType()) {
 435     case 1: {
 436       writer.writeFieldAlways(1 /* field id */, *a_ref());
 437       break;
 438     }
 439     case 2: {
 440       writer.writeFieldAlways(2 /* field id */, *b_ref());
 441       break;
 442     }
 443     case 3: {
 444       writer.writeFieldAlways(3 /* field id */, *c_ref());
 445       break;
 446     }
 447     default:
 448       break;
 449   }
 450   writer.writeFieldStop();
 451   writer.writeStructEnd();
 452 }
 453
 454 template <class V>
 455 void TestUnion::visitFields(V&& v) {
 456   switch (getType()) {
 457     case 1:
 458       v.visitField(1, "a", *a_ref());
 459       break;
 460     case 2:
 461       v.visitField(2, "b", *b_ref());
 462       break;
 463     case 3:
 464       v.visitField(3, "c", *c_ref());
 465       break;
 466     default:
 467       break;
 468   }
 469 }
 470
 471 template <class V>
 472 void TestUnion::visitFields(V&& v) const {
 473   switch (getType()) {
 474     case 1:
 475       v.visitField(1, "a", *a_ref());
 476       break;
 477     case 2:
 478       v.visitField(2, "b", *b_ref());
 479       break;
 480     case 3:
 481       v.visitField(3, "c", *c_ref());
 482       break;
 483     default:
 484       break;
 485   }
 486 }
 487
 488 template <class V>
 489 void TestUnion::foreachMember(V&& v) {
 490   if (!v.template visitUnionMember<uint64_t>("a", [this]() -> uint64_t& {return this->a_ref().emplace();})) {
 491     return;
 492   }
 493   if (!v.template visitUnionMember<uint32_t>("b", [this]() -> uint32_t& {return this->b_ref().emplace();})) {
 494     return;
 495   }
 496   if (!v.template visitUnionMember<uint16_t>("c", [this]() -> uint16_t& {return this->c_ref().emplace();})) {
 497     return;
 498   }
 499 }
 500
 501 template <class Writer>
 502 void TestF14Containers::serialize(Writer&& writer) const {
 503   writer.writeStructBegin();
 504   writer.writeField(1 /* field id */, fastMap_ref());
 505   writer.writeField(2 /* field id */, nodeMap_ref());
 506   writer.writeField(3 /* field id */, valueMap_ref());
 507   writer.writeField(4 /* field id */, vectorMap_ref());
 508   writer.writeField(5 /* field id */, fastSet_ref());
 509   writer.writeField(6 /* field id */, nodeSet_ref());
 510   writer.writeField(7 /* field id */, valueSet_ref());
 511   writer.writeField(8 /* field id */, vectorSet_ref());
 512   writer.writeFieldStop();
 513   writer.writeStructEnd();
 514 }
 515
 516 template <class V>
 517 void TestF14Containers::visitFields(V&& v) {
 518   if (!v.visitField(1, "fastMap", *this->fastMap_ref())) {
 519     return;
 520   }
 521   if (!v.visitField(2, "nodeMap", *this->nodeMap_ref())) {
 522     return;
 523   }
 524   if (!v.visitField(3, "valueMap", *this->valueMap_ref())) {
 525     return;
 526   }
 527   if (!v.visitField(4, "vectorMap", *this->vectorMap_ref())) {
 528     return;
 529   }
 530   if (!v.visitField(5, "fastSet", *this->fastSet_ref())) {
 531     return;
 532   }
 533   if (!v.visitField(6, "nodeSet", *this->nodeSet_ref())) {
 534     return;
 535   }
 536   if (!v.visitField(7, "valueSet", *this->valueSet_ref())) {
 537     return;
 538   }
 539   if (!v.visitField(8, "vectorSet", *this->vectorSet_ref())) {
 540     return;
 541   }
 542 }
 543
 544 template <class V>
 545 void TestF14Containers::visitFields(V&& v) const {
 546   if (!v.visitField(1, "fastMap", *this->fastMap_ref())) {
 547     return;
 548   }
 549   if (!v.visitField(2, "nodeMap", *this->nodeMap_ref())) {
 550     return;
 551   }
 552   if (!v.visitField(3, "valueMap", *this->valueMap_ref())) {
 553     return;
 554   }
 555   if (!v.visitField(4, "vectorMap", *this->vectorMap_ref())) {
 556     return;
 557   }
 558   if (!v.visitField(5, "fastSet", *this->fastSet_ref())) {
 559     return;
 560   }
 561   if (!v.visitField(6, "nodeSet", *this->nodeSet_ref())) {
 562     return;
 563   }
 564   if (!v.visitField(7, "valueSet", *this->valueSet_ref())) {
 565     return;
 566   }
 567   if (!v.visitField(8, "vectorSet", *this->vectorSet_ref())) {
 568     return;
 569   }
 570 }
 571
 572 template <class Writer>
 573 void TestStdContainers::serialize(Writer&& writer) const {
 574   writer.writeStructBegin();
 575   writer.writeField(1 /* field id */, fastMap_ref());
 576   writer.writeField(2 /* field id */, nodeMap_ref());
 577   writer.writeField(3 /* field id */, valueMap_ref());
 578   writer.writeField(4 /* field id */, vectorMap_ref());
 579   writer.writeField(5 /* field id */, fastSet_ref());
 580   writer.writeField(6 /* field id */, nodeSet_ref());
 581   writer.writeField(7 /* field id */, valueSet_ref());
 582   writer.writeField(8 /* field id */, vectorSet_ref());
 583   writer.writeFieldStop();
 584   writer.writeStructEnd();
 585 }
 586
 587 template <class V>
 588 void TestStdContainers::visitFields(V&& v) {
 589   if (!v.visitField(1, "fastMap", *this->fastMap_ref())) {
 590     return;
 591   }
 592   if (!v.visitField(2, "nodeMap", *this->nodeMap_ref())) {
 593     return;
 594   }
 595   if (!v.visitField(3, "valueMap", *this->valueMap_ref())) {
 596     return;
 597   }
 598   if (!v.visitField(4, "vectorMap", *this->vectorMap_ref())) {
 599     return;
 600   }
 601   if (!v.visitField(5, "fastSet", *this->fastSet_ref())) {
 602     return;
 603   }
 604   if (!v.visitField(6, "nodeSet", *this->nodeSet_ref())) {
 605     return;
 606   }
 607   if (!v.visitField(7, "valueSet", *this->valueSet_ref())) {
 608     return;
 609   }
 610   if (!v.visitField(8, "vectorSet", *this->vectorSet_ref())) {
 611     return;
 612   }
 613 }
 614
 615 template <class V>
 616 void TestStdContainers::visitFields(V&& v) const {
 617   if (!v.visitField(1, "fastMap", *this->fastMap_ref())) {
 618     return;
 619   }
 620   if (!v.visitField(2, "nodeMap", *this->nodeMap_ref())) {
 621     return;
 622   }
 623   if (!v.visitField(3, "valueMap", *this->valueMap_ref())) {
 624     return;
 625   }
 626   if (!v.visitField(4, "vectorMap", *this->vectorMap_ref())) {
 627     return;
 628   }
 629   if (!v.visitField(5, "fastSet", *this->fastSet_ref())) {
 630     return;
 631   }
 632   if (!v.visitField(6, "nodeSet", *this->nodeSet_ref())) {
 633     return;
 634   }
 635   if (!v.visitField(7, "valueSet", *this->valueSet_ref())) {
 636     return;
 637   }
 638   if (!v.visitField(8, "vectorSet", *this->vectorSet_ref())) {
 639     return;
 640   }
 641 }
 642
 643 template <class Writer>
 644 void StructWithEnumUInt32::serialize(Writer&& writer) const {
 645   writer.writeStructBegin();
 646   writer.writeField(1 /* field id */, testEnum_ref());
 647   writer.writeFieldStop();
 648   writer.writeStructEnd();
 649 }
 650
 651 template <class V>
 652 void StructWithEnumUInt32::visitFields(V&& v) {
 653   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 654     return;
 655   }
 656 }
 657
 658 template <class V>
 659 void StructWithEnumUInt32::visitFields(V&& v) const {
 660   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 661     return;
 662   }
 663 }
 664
 665 template <class Writer>
 666 void StructWithEnumUInt16::serialize(Writer&& writer) const {
 667   writer.writeStructBegin();
 668   writer.writeField(1 /* field id */, testEnum_ref());
 669   writer.writeFieldStop();
 670   writer.writeStructEnd();
 671 }
 672
 673 template <class V>
 674 void StructWithEnumUInt16::visitFields(V&& v) {
 675   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 676     return;
 677   }
 678 }
 679
 680 template <class V>
 681 void StructWithEnumUInt16::visitFields(V&& v) const {
 682   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 683     return;
 684   }
 685 }
 686
 687 template <class Writer>
 688 void StructWithEnumUInt8::serialize(Writer&& writer) const {
 689   writer.writeStructBegin();
 690   writer.writeField(1 /* field id */, testEnum_ref());
 691   writer.writeFieldStop();
 692   writer.writeStructEnd();
 693 }
 694
 695 template <class V>
 696 void StructWithEnumUInt8::visitFields(V&& v) {
 697   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 698     return;
 699   }
 700 }
 701
 702 template <class V>
 703 void StructWithEnumUInt8::visitFields(V&& v) const {
 704   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 705     return;
 706   }
 707 }
 708
 709 template <class Writer>
 710 void StructWithEnumInt32::serialize(Writer&& writer) const {
 711   writer.writeStructBegin();
 712   writer.writeField(1 /* field id */, testEnum_ref());
 713   writer.writeFieldStop();
 714   writer.writeStructEnd();
 715 }
 716
 717 template <class V>
 718 void StructWithEnumInt32::visitFields(V&& v) {
 719   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 720     return;
 721   }
 722 }
 723
 724 template <class V>
 725 void StructWithEnumInt32::visitFields(V&& v) const {
 726   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 727     return;
 728   }
 729 }
 730
 731 template <class Writer>
 732 void StructWithEnumInt16::serialize(Writer&& writer) const {
 733   writer.writeStructBegin();
 734   writer.writeField(1 /* field id */, testEnum_ref());
 735   writer.writeFieldStop();
 736   writer.writeStructEnd();
 737 }
 738
 739 template <class V>
 740 void StructWithEnumInt16::visitFields(V&& v) {
 741   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 742     return;
 743   }
 744 }
 745
 746 template <class V>
 747 void StructWithEnumInt16::visitFields(V&& v) const {
 748   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 749     return;
 750   }
 751 }
 752
 753 template <class Writer>
 754 void StructWithEnumInt8::serialize(Writer&& writer) const {
 755   writer.writeStructBegin();
 756   writer.writeField(1 /* field id */, testEnum_ref());
 757   writer.writeFieldStop();
 758   writer.writeStructEnd();
 759 }
 760
 761 template <class V>
 762 void StructWithEnumInt8::visitFields(V&& v) {
 763   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 764     return;
 765   }
 766 }
 767
 768 template <class V>
 769 void StructWithEnumInt8::visitFields(V&& v) const {
 770   if (!v.visitField(1, "testEnum", *this->testEnum_ref())) {
 771     return;
 772   }
 773 }
 774
 775 template <class Writer>
 776 void StructWithOptionalEnumUInt32::serialize(Writer&& writer) const {
 777   writer.writeStructBegin();
 778   writer.writeField(1 /* field id */, testEnum_ref());
 779   writer.writeField(2 /* field id */, testEmptyEnum_ref());
 780   writer.writeFieldStop();
 781   writer.writeStructEnd();
 782 }
 783
 784 template <class V>
 785 void StructWithOptionalEnumUInt32::visitFields(V&& v) {
 786   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 787     return;
 788   }
 789   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 790     return;
 791   }
 792 }
 793
 794 template <class V>
 795 void StructWithOptionalEnumUInt32::visitFields(V&& v) const {
 796   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 797     return;
 798   }
 799   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 800     return;
 801   }
 802 }
 803
 804 template <class Writer>
 805 void StructWithOptionalEnumUInt16::serialize(Writer&& writer) const {
 806   writer.writeStructBegin();
 807   writer.writeField(1 /* field id */, testEnum_ref());
 808   writer.writeField(2 /* field id */, testEmptyEnum_ref());
 809   writer.writeFieldStop();
 810   writer.writeStructEnd();
 811 }
 812
 813 template <class V>
 814 void StructWithOptionalEnumUInt16::visitFields(V&& v) {
 815   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 816     return;
 817   }
 818   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 819     return;
 820   }
 821 }
 822
 823 template <class V>
 824 void StructWithOptionalEnumUInt16::visitFields(V&& v) const {
 825   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 826     return;
 827   }
 828   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 829     return;
 830   }
 831 }
 832
 833 template <class Writer>
 834 void StructWithOptionalEnumUInt8::serialize(Writer&& writer) const {
 835   writer.writeStructBegin();
 836   writer.writeField(1 /* field id */, testEnum_ref());
 837   writer.writeField(2 /* field id */, testEmptyEnum_ref());
 838   writer.writeFieldStop();
 839   writer.writeStructEnd();
 840 }
 841
 842 template <class V>
 843 void StructWithOptionalEnumUInt8::visitFields(V&& v) {
 844   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 845     return;
 846   }
 847   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 848     return;
 849   }
 850 }
 851
 852 template <class V>
 853 void StructWithOptionalEnumUInt8::visitFields(V&& v) const {
 854   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 855     return;
 856   }
 857   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 858     return;
 859   }
 860 }
 861
 862 template <class Writer>
 863 void StructWithOptionalEnumInt32::serialize(Writer&& writer) const {
 864   writer.writeStructBegin();
 865   writer.writeField(1 /* field id */, testEnum_ref());
 866   writer.writeField(2 /* field id */, testEmptyEnum_ref());
 867   writer.writeFieldStop();
 868   writer.writeStructEnd();
 869 }
 870
 871 template <class V>
 872 void StructWithOptionalEnumInt32::visitFields(V&& v) {
 873   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 874     return;
 875   }
 876   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 877     return;
 878   }
 879 }
 880
 881 template <class V>
 882 void StructWithOptionalEnumInt32::visitFields(V&& v) const {
 883   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 884     return;
 885   }
 886   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 887     return;
 888   }
 889 }
 890
 891 template <class Writer>
 892 void StructWithOptionalEnumInt16::serialize(Writer&& writer) const {
 893   writer.writeStructBegin();
 894   writer.writeField(1 /* field id */, testEnum_ref());
 895   writer.writeField(2 /* field id */, testEmptyEnum_ref());
 896   writer.writeFieldStop();
 897   writer.writeStructEnd();
 898 }
 899
 900 template <class V>
 901 void StructWithOptionalEnumInt16::visitFields(V&& v) {
 902   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 903     return;
 904   }
 905   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 906     return;
 907   }
 908 }
 909
 910 template <class V>
 911 void StructWithOptionalEnumInt16::visitFields(V&& v) const {
 912   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 913     return;
 914   }
 915   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 916     return;
 917   }
 918 }
 919
 920 template <class Writer>
 921 void StructWithOptionalEnumInt8::serialize(Writer&& writer) const {
 922   writer.writeStructBegin();
 923   writer.writeField(1 /* field id */, testEnum_ref());
 924   writer.writeField(2 /* field id */, testEmptyEnum_ref());
 925   writer.writeFieldStop();
 926   writer.writeStructEnd();
 927 }
 928
 929 template <class V>
 930 void StructWithOptionalEnumInt8::visitFields(V&& v) {
 931   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 932     return;
 933   }
 934   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 935     return;
 936   }
 937 }
 938
 939 template <class V>
 940 void StructWithOptionalEnumInt8::visitFields(V&& v) const {
 941   if (!v.visitField(1, "testEnum", this->testEnum_ref())) {
 942     return;
 943   }
 944   if (!v.visitField(2, "testEmptyEnum", this->testEmptyEnum_ref())) {
 945     return;
 946   }
 947 }
 948 } // namespace thrift
 949 } // namespace test
 950 } // namespace carbon
 951
 952 namespace apache {
 953 namespace thrift {
 954 template <>
 955 class Cpp2Ops<carbon::test::TestRequest> {
 956  public:
 957   typedef carbon::test::TestRequest Type;
 958   static constexpr protocol::TType thriftType() {
 959     return protocol::T_STRUCT;
 960   }
 961   template <class Protocol>
 962   static uint32_t write(Protocol* prot, const Type* value) {
 963     return value->write(prot);
 964   }
 965   template <class Protocol>
 966   static void read(Protocol* prot, Type* value) {
 967     value->read(prot);
 968   }
 969   template <class Protocol>
 970   static uint32_t serializedSize(Protocol* prot, const Type* value) {
 971     return value->serializedSize(prot);
 972   }
 973   template <class Protocol>
 974   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
 975     return value->serializedSizeZC(prot);
 976   }
 977 };
 978
 979 template <>
 980 class Cpp2Ops<carbon::test::TestReply> {
 981  public:
 982   typedef carbon::test::TestReply Type;
 983   static constexpr protocol::TType thriftType() {
 984     return protocol::T_STRUCT;
 985   }
 986   template <class Protocol>
 987   static uint32_t write(Protocol* prot, const Type* value) {
 988     return value->write(prot);
 989   }
 990   template <class Protocol>
 991   static void read(Protocol* prot, Type* value) {
 992     value->read(prot);
 993   }
 994   template <class Protocol>
 995   static uint32_t serializedSize(Protocol* prot, const Type* value) {
 996     return value->serializedSize(prot);
 997   }
 998   template <class Protocol>
 999   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1000     return value->serializedSizeZC(prot);
1001   }
1002 };
1003
1004 template <>
1005 class Cpp2Ops<carbon::test::TestRequestStringKey> {
1006  public:
1007   typedef carbon::test::TestRequestStringKey Type;
1008   static constexpr protocol::TType thriftType() {
1009     return protocol::T_STRUCT;
1010   }
1011   template <class Protocol>
1012   static uint32_t write(Protocol* prot, const Type* value) {
1013     return value->write(prot);
1014   }
1015   template <class Protocol>
1016   static void read(Protocol* prot, Type* value) {
1017     value->read(prot);
1018   }
1019   template <class Protocol>
1020   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1021     return value->serializedSize(prot);
1022   }
1023   template <class Protocol>
1024   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1025     return value->serializedSizeZC(prot);
1026   }
1027 };
1028
1029 template <>
1030 class Cpp2Ops<carbon::test::TestReplyStringKey> {
1031  public:
1032   typedef carbon::test::TestReplyStringKey Type;
1033   static constexpr protocol::TType thriftType() {
1034     return protocol::T_STRUCT;
1035   }
1036   template <class Protocol>
1037   static uint32_t write(Protocol* prot, const Type* value) {
1038     return value->write(prot);
1039   }
1040   template <class Protocol>
1041   static void read(Protocol* prot, Type* value) {
1042     value->read(prot);
1043   }
1044   template <class Protocol>
1045   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1046     return value->serializedSize(prot);
1047   }
1048   template <class Protocol>
1049   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1050     return value->serializedSizeZC(prot);
1051   }
1052 };
1053
1054 template <>
1055 class Cpp2Ops<carbon::test::TestOptionalBool> {
1056  public:
1057   typedef carbon::test::TestOptionalBool Type;
1058   static constexpr protocol::TType thriftType() {
1059     return protocol::T_STRUCT;
1060   }
1061   template <class Protocol>
1062   static uint32_t write(Protocol* prot, const Type* value) {
1063     return value->write(prot);
1064   }
1065   template <class Protocol>
1066   static void read(Protocol* prot, Type* value) {
1067     value->read(prot);
1068   }
1069   template <class Protocol>
1070   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1071     return value->serializedSize(prot);
1072   }
1073   template <class Protocol>
1074   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1075     return value->serializedSizeZC(prot);
1076   }
1077 };
1078
1079 template <>
1080 class Cpp2Ops<carbon::test::TestUnion> {
1081  public:
1082   typedef carbon::test::TestUnion Type;
1083   static constexpr protocol::TType thriftType() {
1084     return protocol::T_STRUCT;
1085   }
1086   template <class Protocol>
1087   static uint32_t write(Protocol* prot, const Type* value) {
1088     return value->write(prot);
1089   }
1090   template <class Protocol>
1091   static void read(Protocol* prot, Type* value) {
1092     value->read(prot);
1093   }
1094   template <class Protocol>
1095   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1096     return value->serializedSize(prot);
1097   }
1098   template <class Protocol>
1099   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1100     return value->serializedSizeZC(prot);
1101   }
1102 };
1103
1104 template <>
1105 class Cpp2Ops<carbon::test::TestF14Containers> {
1106  public:
1107   typedef carbon::test::TestF14Containers Type;
1108   static constexpr protocol::TType thriftType() {
1109     return protocol::T_STRUCT;
1110   }
1111   template <class Protocol>
1112   static uint32_t write(Protocol* prot, const Type* value) {
1113     return value->write(prot);
1114   }
1115   template <class Protocol>
1116   static void read(Protocol* prot, Type* value) {
1117     value->read(prot);
1118   }
1119   template <class Protocol>
1120   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1121     return value->serializedSize(prot);
1122   }
1123   template <class Protocol>
1124   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1125     return value->serializedSizeZC(prot);
1126   }
1127 };
1128
1129 template <>
1130 class Cpp2Ops<carbon::test::TestStdContainers> {
1131  public:
1132   typedef carbon::test::TestStdContainers Type;
1133   static constexpr protocol::TType thriftType() {
1134     return protocol::T_STRUCT;
1135   }
1136   template <class Protocol>
1137   static uint32_t write(Protocol* prot, const Type* value) {
1138     return value->write(prot);
1139   }
1140   template <class Protocol>
1141   static void read(Protocol* prot, Type* value) {
1142     value->read(prot);
1143   }
1144   template <class Protocol>
1145   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1146     return value->serializedSize(prot);
1147   }
1148   template <class Protocol>
1149   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1150     return value->serializedSizeZC(prot);
1151   }
1152 };
1153
1154 template <>
1155 class Cpp2Ops<carbon::test::StructWithEnumUInt32> {
1156  public:
1157   typedef carbon::test::StructWithEnumUInt32 Type;
1158   static constexpr protocol::TType thriftType() {
1159     return protocol::T_STRUCT;
1160   }
1161   template <class Protocol>
1162   static uint32_t write(Protocol* prot, const Type* value) {
1163     return value->write(prot);
1164   }
1165   template <class Protocol>
1166   static void read(Protocol* prot, Type* value) {
1167     value->read(prot);
1168   }
1169   template <class Protocol>
1170   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1171     return value->serializedSize(prot);
1172   }
1173   template <class Protocol>
1174   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1175     return value->serializedSizeZC(prot);
1176   }
1177 };
1178
1179 template <>
1180 class Cpp2Ops<carbon::test::StructWithEnumUInt16> {
1181  public:
1182   typedef carbon::test::StructWithEnumUInt16 Type;
1183   static constexpr protocol::TType thriftType() {
1184     return protocol::T_STRUCT;
1185   }
1186   template <class Protocol>
1187   static uint32_t write(Protocol* prot, const Type* value) {
1188     return value->write(prot);
1189   }
1190   template <class Protocol>
1191   static void read(Protocol* prot, Type* value) {
1192     value->read(prot);
1193   }
1194   template <class Protocol>
1195   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1196     return value->serializedSize(prot);
1197   }
1198   template <class Protocol>
1199   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1200     return value->serializedSizeZC(prot);
1201   }
1202 };
1203
1204 template <>
1205 class Cpp2Ops<carbon::test::StructWithEnumUInt8> {
1206  public:
1207   typedef carbon::test::StructWithEnumUInt8 Type;
1208   static constexpr protocol::TType thriftType() {
1209     return protocol::T_STRUCT;
1210   }
1211   template <class Protocol>
1212   static uint32_t write(Protocol* prot, const Type* value) {
1213     return value->write(prot);
1214   }
1215   template <class Protocol>
1216   static void read(Protocol* prot, Type* value) {
1217     value->read(prot);
1218   }
1219   template <class Protocol>
1220   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1221     return value->serializedSize(prot);
1222   }
1223   template <class Protocol>
1224   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1225     return value->serializedSizeZC(prot);
1226   }
1227 };
1228
1229 template <>
1230 class Cpp2Ops<carbon::test::StructWithEnumInt32> {
1231  public:
1232   typedef carbon::test::StructWithEnumInt32 Type;
1233   static constexpr protocol::TType thriftType() {
1234     return protocol::T_STRUCT;
1235   }
1236   template <class Protocol>
1237   static uint32_t write(Protocol* prot, const Type* value) {
1238     return value->write(prot);
1239   }
1240   template <class Protocol>
1241   static void read(Protocol* prot, Type* value) {
1242     value->read(prot);
1243   }
1244   template <class Protocol>
1245   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1246     return value->serializedSize(prot);
1247   }
1248   template <class Protocol>
1249   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1250     return value->serializedSizeZC(prot);
1251   }
1252 };
1253
1254 template <>
1255 class Cpp2Ops<carbon::test::StructWithEnumInt16> {
1256  public:
1257   typedef carbon::test::StructWithEnumInt16 Type;
1258   static constexpr protocol::TType thriftType() {
1259     return protocol::T_STRUCT;
1260   }
1261   template <class Protocol>
1262   static uint32_t write(Protocol* prot, const Type* value) {
1263     return value->write(prot);
1264   }
1265   template <class Protocol>
1266   static void read(Protocol* prot, Type* value) {
1267     value->read(prot);
1268   }
1269   template <class Protocol>
1270   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1271     return value->serializedSize(prot);
1272   }
1273   template <class Protocol>
1274   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1275     return value->serializedSizeZC(prot);
1276   }
1277 };
1278
1279 template <>
1280 class Cpp2Ops<carbon::test::StructWithEnumInt8> {
1281  public:
1282   typedef carbon::test::StructWithEnumInt8 Type;
1283   static constexpr protocol::TType thriftType() {
1284     return protocol::T_STRUCT;
1285   }
1286   template <class Protocol>
1287   static uint32_t write(Protocol* prot, const Type* value) {
1288     return value->write(prot);
1289   }
1290   template <class Protocol>
1291   static void read(Protocol* prot, Type* value) {
1292     value->read(prot);
1293   }
1294   template <class Protocol>
1295   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1296     return value->serializedSize(prot);
1297   }
1298   template <class Protocol>
1299   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1300     return value->serializedSizeZC(prot);
1301   }
1302 };
1303
1304 template <>
1305 class Cpp2Ops<carbon::test::StructWithOptionalEnumUInt32> {
1306  public:
1307   typedef carbon::test::StructWithOptionalEnumUInt32 Type;
1308   static constexpr protocol::TType thriftType() {
1309     return protocol::T_STRUCT;
1310   }
1311   template <class Protocol>
1312   static uint32_t write(Protocol* prot, const Type* value) {
1313     return value->write(prot);
1314   }
1315   template <class Protocol>
1316   static void read(Protocol* prot, Type* value) {
1317     value->read(prot);
1318   }
1319   template <class Protocol>
1320   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1321     return value->serializedSize(prot);
1322   }
1323   template <class Protocol>
1324   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1325     return value->serializedSizeZC(prot);
1326   }
1327 };
1328
1329 template <>
1330 class Cpp2Ops<carbon::test::StructWithOptionalEnumUInt16> {
1331  public:
1332   typedef carbon::test::StructWithOptionalEnumUInt16 Type;
1333   static constexpr protocol::TType thriftType() {
1334     return protocol::T_STRUCT;
1335   }
1336   template <class Protocol>
1337   static uint32_t write(Protocol* prot, const Type* value) {
1338     return value->write(prot);
1339   }
1340   template <class Protocol>
1341   static void read(Protocol* prot, Type* value) {
1342     value->read(prot);
1343   }
1344   template <class Protocol>
1345   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1346     return value->serializedSize(prot);
1347   }
1348   template <class Protocol>
1349   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1350     return value->serializedSizeZC(prot);
1351   }
1352 };
1353
1354 template <>
1355 class Cpp2Ops<carbon::test::StructWithOptionalEnumUInt8> {
1356  public:
1357   typedef carbon::test::StructWithOptionalEnumUInt8 Type;
1358   static constexpr protocol::TType thriftType() {
1359     return protocol::T_STRUCT;
1360   }
1361   template <class Protocol>
1362   static uint32_t write(Protocol* prot, const Type* value) {
1363     return value->write(prot);
1364   }
1365   template <class Protocol>
1366   static void read(Protocol* prot, Type* value) {
1367     value->read(prot);
1368   }
1369   template <class Protocol>
1370   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1371     return value->serializedSize(prot);
1372   }
1373   template <class Protocol>
1374   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1375     return value->serializedSizeZC(prot);
1376   }
1377 };
1378
1379 template <>
1380 class Cpp2Ops<carbon::test::StructWithOptionalEnumInt32> {
1381  public:
1382   typedef carbon::test::StructWithOptionalEnumInt32 Type;
1383   static constexpr protocol::TType thriftType() {
1384     return protocol::T_STRUCT;
1385   }
1386   template <class Protocol>
1387   static uint32_t write(Protocol* prot, const Type* value) {
1388     return value->write(prot);
1389   }
1390   template <class Protocol>
1391   static void read(Protocol* prot, Type* value) {
1392     value->read(prot);
1393   }
1394   template <class Protocol>
1395   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1396     return value->serializedSize(prot);
1397   }
1398   template <class Protocol>
1399   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1400     return value->serializedSizeZC(prot);
1401   }
1402 };
1403
1404 template <>
1405 class Cpp2Ops<carbon::test::StructWithOptionalEnumInt16> {
1406  public:
1407   typedef carbon::test::StructWithOptionalEnumInt16 Type;
1408   static constexpr protocol::TType thriftType() {
1409     return protocol::T_STRUCT;
1410   }
1411   template <class Protocol>
1412   static uint32_t write(Protocol* prot, const Type* value) {
1413     return value->write(prot);
1414   }
1415   template <class Protocol>
1416   static void read(Protocol* prot, Type* value) {
1417     value->read(prot);
1418   }
1419   template <class Protocol>
1420   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1421     return value->serializedSize(prot);
1422   }
1423   template <class Protocol>
1424   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1425     return value->serializedSizeZC(prot);
1426   }
1427 };
1428
1429 template <>
1430 class Cpp2Ops<carbon::test::StructWithOptionalEnumInt8> {
1431  public:
1432   typedef carbon::test::StructWithOptionalEnumInt8 Type;
1433   static constexpr protocol::TType thriftType() {
1434     return protocol::T_STRUCT;
1435   }
1436   template <class Protocol>
1437   static uint32_t write(Protocol* prot, const Type* value) {
1438     return value->write(prot);
1439   }
1440   template <class Protocol>
1441   static void read(Protocol* prot, Type* value) {
1442     value->read(prot);
1443   }
1444   template <class Protocol>
1445   static uint32_t serializedSize(Protocol* prot, const Type* value) {
1446     return value->serializedSize(prot);
1447   }
1448   template <class Protocol>
1449   static uint32_t serializedSizeZC(Protocol* prot, const Type* value) {
1450     return value->serializedSizeZC(prot);
1451   }
1452 };
1453 } // namespace thrift
1454 } // namespace apache