op::decode for basic types

Summary: Added `op::decode(Protocol& prot, T& value)` to Decode.h, which decodes the  value to the given protocol using the type tag. Support for containers, structs, and adapted types will be in next diff.

Reviewed By: Mizuchi

Differential Revision: D39058761

fbshipit-source-id: 74f33be018beed7f9712412d35120c60ace329de

Author: ami7o

third-party/thrift/src/thrift/lib/cpp2/op/Encode.h

@@ -28,6 +28,12 @@ namespace op {
 template <typename Tag>
 FOLLY_INLINE_VARIABLE constexpr detail::Encode<Tag> encode{};
 
+// Decodes the value from the given protocol using the type tag.
+// This handles adapted type.
+// For example: decode<type::int16_t>(prot, i); // decode to variable i
+template <typename Tag>
+FOLLY_INLINE_VARIABLE constexpr detail::Decode<Tag> decode{};
+
 } // namespace op
 } // namespace thrift
 } // namespace apache

third-party/thrift/src/thrift/lib/cpp2/op/EncodeTest.cpp

@@ -213,5 +213,43 @@ TEST(EncodeTest, EncodeAdapted) {
   testEncodeAdapted<conformance::StandardProtocol::Binary>();
   testEncodeAdapted<conformance::StandardProtocol::Compact>();
 }
+
+template <conformance::StandardProtocol Protocol, typename Tag, typename T>
+void testDecode(T value) {
+  SCOPED_TRACE(folly::pretty_name<Tag>());
+  protocol_writer_t<Protocol> writer;
+  folly::IOBufQueue queue;
+  writer.setOutput(&queue);
+  encode<Tag>(writer, value);
+
+  protocol_reader_t<Protocol> reader;
+  auto serialized = queue.move();
+  reader.setInput(serialized.get());
+  T result;
+  decode<Tag>(reader, result);
+  EXPECT_EQ(result, value);
+}
+
+template <conformance::StandardProtocol Protocol>
+void testDecodeBasicTypes() {
+  SCOPED_TRACE(apache::thrift::util::enumNameSafe(Protocol));
+  testDecode<Protocol, type::bool_t>(true);
+  testDecode<Protocol, type::byte_t>((int8_t)1);
+  testDecode<Protocol, type::i16_t>((int16_t)11);
+  testDecode<Protocol, type::i32_t>((int32_t)11);
+  testDecode<Protocol, type::i64_t>((int64_t)11);
+  testDecode<Protocol, type::float_t>(1.5f);
+  testDecode<Protocol, type::double_t>(1.5);
+  testDecode<Protocol, type::string_t>(std::string("foo"));
+  testDecode<Protocol, type::binary_t>(std::string("foo"));
+  enum class MyEnum { value = 1 };
+  testDecode<Protocol, type::enum_t<MyEnum>>(MyEnum::value);
+}
+
+TEST(DecodeTest, DecodeBasicTypes) {
+  testDecodeBasicTypes<conformance::StandardProtocol::Binary>();
+  testDecodeBasicTypes<conformance::StandardProtocol::Compact>();
+}
+
 } // namespace
 } // namespace apache::thrift::op

third-party/thrift/src/thrift/lib/cpp2/op/detail/Encode.h

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <utility>
 #include <thrift/lib/cpp/protocol/TType.h>
 #include <thrift/lib/cpp2/type/NativeType.h>
 #include <thrift/lib/cpp2/type/Tag.h>
@@ -276,6 +277,91 @@ struct Encode<type::adapted<Adapter, Tag>> {
   }
 };
 
+template <typename>
+struct Decode;
+
+template <>
+struct Decode<type::bool_t> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, bool& b) const {
+    prot.readBool(b);
+  }
+};
+
+template <>
+struct Decode<type::byte_t> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, int8_t& i) const {
+    prot.readByte(i);
+  }
+};
+
+template <>
+struct Decode<type::i16_t> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, int16_t& i) const {
+    prot.readI16(i);
+  }
+};
+
+template <>
+struct Decode<type::i32_t> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, int32_t& i) const {
+    prot.readI32(i);
+  }
+};
+
+template <>
+struct Decode<type::i64_t> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, int64_t& i) const {
+    prot.readI64(i);
+  }
+};
+
+template <>
+struct Decode<type::float_t> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, float& f) const {
+    prot.readFloat(f);
+  }
+};
+
+template <>
+struct Decode<type::double_t> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, double& d) const {
+    prot.readDouble(d);
+  }
+};
+
+template <>
+struct Decode<type::string_t> {
+  template <typename Protocol, typename StrType>
+  void operator()(Protocol& prot, StrType& s) const {
+    prot.readString(s);
+  }
+};
+
+template <>
+struct Decode<type::binary_t> {
+  template <typename Protocol, typename StrType>
+  void operator()(Protocol& prot, StrType& s) const {
+    prot.readBinary(s);
+  }
+};
+
+template <typename T>
+struct Decode<type::enum_t<T>> {
+  template <typename Protocol>
+  void operator()(Protocol& prot, T& t) const {
+    int32_t i;
+    prot.readI32(i);
+    t = static_cast<T>(i);
+  }
+};
+
 } // namespace detail
 } // namespace op
 } // namespace thrift