Added GRPC code generator to flatc.

Also added simple (in-process) test.

Change-Id: I38580d554dd52f590e3396ec4846e07546dcf07d
Tested: on Linux.

include/flatbuffers/flatbuffers.h

@@ -1334,6 +1334,29 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   size_t max_tables_;
 };
 
+// Convenient way to bundle a buffer and its length, to pass it around
+// typed by its root.
+// A BufferRef does not own its buffer.
+struct BufferRefBase {};  // for std::is_base_of
+template<typename T> struct BufferRef : BufferRefBase {
+  BufferRef() : buf(nullptr), len(0), must_free(false) {}
+  BufferRef(uint8_t *_buf, uoffset_t _len)
+    : buf(_buf), len(_len), must_free(false) {}
+
+  ~BufferRef() { if (must_free) free(buf); }
+
+  const T *GetRoot() const { return flatbuffers::GetRoot<T>(buf); }
+
+  bool Verify() {
+    Verifier verifier(buf, len);
+    return verifier.VerifyBuffer<T>();
+  }
+
+  uint8_t *buf;
+  uoffset_t len;
+  bool must_free;
+};
+
 // "structs" are flat structures that do not have an offset table, thus
 // always have all members present and do not support forwards/backwards
 // compatible extensions.

include/flatbuffers/grpc.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_GRPC_H_
+#define FLATBUFFERS_GRPC_H_
+
+// Helper functionality to glue FlatBuffers and GRPC.
+
+#include "grpc++/support/byte_buffer.h"
+#include "grpc/byte_buffer_reader.h"
+
+namespace grpc {
+
+template <class T>
+class SerializationTraits<T, typename std::enable_if<std::is_base_of<
+                                 flatbuffers::BufferRefBase, T>::value>::type> {
+ public:
+  // The type we're passing here is a BufferRef, which is already serialized
+  // FlatBuffer data, which then gets passed to GRPC.
+  static grpc::Status Serialize(const T& msg,
+                                grpc_byte_buffer **buffer,
+                                bool *own_buffer) {
+    // TODO(wvo): make this work without copying.
+    auto slice = gpr_slice_from_copied_buffer(
+                   reinterpret_cast<const char *>(msg.buf), msg.len);
+    *buffer = grpc_raw_byte_buffer_create(&slice, 1);
+    *own_buffer = true;
+    return grpc::Status();
+  }
+
+  // There is no de-serialization step in FlatBuffers, so we just receive
+  // the data from GRPC.
+  static grpc::Status Deserialize(grpc_byte_buffer *buffer,
+                                  T *msg,
+                                  int max_message_size) {
+    // TODO(wvo): make this more efficient / zero copy when possible.
+    auto len = grpc_byte_buffer_length(buffer);
+    msg->buf = reinterpret_cast<uint8_t *>(malloc(len));
+    msg->len = static_cast<flatbuffers::uoffset_t>(len);
+    msg->must_free = true;
+    uint8_t *current = msg->buf;
+    grpc_byte_buffer_reader reader;
+    grpc_byte_buffer_reader_init(&reader, buffer);
+    gpr_slice slice;
+    while (grpc_byte_buffer_reader_next(&reader, &slice)) {
+      memcpy(current, GPR_SLICE_START_PTR(slice), GPR_SLICE_LENGTH(slice));
+      current += GPR_SLICE_LENGTH(slice);
+      gpr_slice_unref(slice);
+    }
+    GPR_ASSERT(current == msg->buf + msg->len);
+    grpc_byte_buffer_reader_destroy(&reader);
+    grpc_byte_buffer_destroy(buffer);
+    return grpc::Status();
+  }
+};
+
+}  // namespace grpc;
+
+#endif  // FLATBUFFERS_GRPC_H_

include/flatbuffers/idl.h

@@ -432,7 +432,7 @@ class Parser : public ParserState {
     known_attributes_["original_order"] = true;
     known_attributes_["nested_flatbuffer"] = true;
     known_attributes_["csharp_partial"] = true;
-    known_attributes_["stream"] = true;
+    known_attributes_["streaming"] = true;
     known_attributes_["idempotent"] = true;
   }
 
@@ -679,6 +679,12 @@ extern std::string BinaryMakeRule(const Parser &parser,
                                   const std::string &path,
                                   const std::string &file_name);
 
+// Generate GRPC interfaces.
+// See idl_gen_grpc.cpp.
+bool GenerateGRPC(const Parser &parser,
+                  const std::string &path,
+                  const std::string &file_name);
+
 }  // namespace flatbuffers
 
 #endif  // FLATBUFFERS_IDL_H_