Initial commit of the FlatBuffers code.

Change-Id: I4c9f0f722490b374257adb3fec63e44ae93da920
Tested: using VS2010 / Xcode / gcc on Linux.

5 files changed, 238 insertions, 0 deletions

diff --git a/samples/monster.fbs b/samples/monster.fbs
new file mode 100755
index 00000000..2ad0c926
--- /dev/null
+++ b/samples/monster.fbs
@@ -0,0 +1,25 @@
+// example IDL file
+
+namespace MyGame.Sample;
+
+enum Color:byte { Red = 0, Green, Blue = 2 }
+
+union Any { Monster }  // add more elements..
+
+struct Vec3 {
+  x:float;
+  y:float;
+  z:float;
+}
+
+table Monster {
+  pos:Vec3;
+  mana:short = 150;
+  hp:short = 100;
+  name:string;
+  friendly:bool = false (deprecated);
+  inventory:[ubyte];
+  color:Color = Blue;
+}
+
+root_type Monster;
diff --git a/samples/monster_generated.h b/samples/monster_generated.h
new file mode 100755
index 00000000..8282a84a
--- /dev/null
+++ b/samples/monster_generated.h
@@ -0,0 +1,88 @@
+// automatically generated, do not modify
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace MyGame {
+namespace Sample {
+
+enum {
+  Color_Red = 0,
+  Color_Green = 1,
+  Color_Blue = 2,
+};
+
+inline const char **EnumNamesColor() {
+  static const char *names[] = { "Red", "Green", "Blue", nullptr };
+  return names;
+}
+
+inline const char *EnumNameColor(int e) { return EnumNamesColor()[e]; }
+
+enum {
+  Any_NONE = 0,
+  Any_Monster = 1,
+};
+
+inline const char **EnumNamesAny() {
+  static const char *names[] = { "NONE", "Monster", nullptr };
+  return names;
+}
+
+inline const char *EnumNameAny(int e) { return EnumNamesAny()[e]; }
+
+struct Vec3;
+struct Monster;
+
+MANUALLY_ALIGNED_STRUCT(4) Vec3 {
+ private:
+  float x_;
+  float y_;
+  float z_;
+
+ public:
+  Vec3(float x, float y, float z)
+    : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)), z_(flatbuffers::EndianScalar(z)) {}
+
+  float x() const { return flatbuffers::EndianScalar(x_); }
+  float y() const { return flatbuffers::EndianScalar(y_); }
+  float z() const { return flatbuffers::EndianScalar(z_); }
+};
+STRUCT_END(Vec3, 12);
+
+struct Monster : private flatbuffers::Table {
+  const Vec3 *pos() const { return GetStruct<const Vec3 *>(4); }
+  int16_t mana() const { return GetField<int16_t>(6, 150); }
+  int16_t hp() const { return GetField<int16_t>(8, 100); }
+  const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(10); }
+  const flatbuffers::Vector<uint8_t> *inventory() const { return GetPointer<const flatbuffers::Vector<uint8_t> *>(14); }
+  int8_t color() const { return GetField<int8_t>(16, 2); }
+};
+
+struct MonsterBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_pos(const Vec3 *pos) { fbb_.AddStruct(4, pos); }
+  void add_mana(int16_t mana) { fbb_.AddElement<int16_t>(6, mana, 150); }
+  void add_hp(int16_t hp) { fbb_.AddElement<int16_t>(8, hp, 100); }
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(10, name); }
+  void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) { fbb_.AddOffset(14, inventory); }
+  void add_color(int8_t color) { fbb_.AddElement<int8_t>(16, color, 2); }
+  MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
+  flatbuffers::Offset<Monster> Finish() { return flatbuffers::Offset<Monster>(fbb_.EndTable(start_, 7)); }
+};
+
+inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const Vec3 *pos, int16_t mana, int16_t hp, flatbuffers::Offset<flatbuffers::String> name, flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory, int8_t color) {
+  MonsterBuilder builder_(_fbb);
+  builder_.add_inventory(inventory);
+  builder_.add_name(name);
+  builder_.add_pos(pos);
+  builder_.add_hp(hp);
+  builder_.add_mana(mana);
+  builder_.add_color(color);
+  return builder_.Finish();
+}
+
+inline const Monster *GetMonster(const void *buf) { return flatbuffers::GetRoot<Monster>(buf); }
+
+}; // namespace MyGame
+}; // namespace Sample
diff --git a/samples/monsterdata.json b/samples/monsterdata.json
new file mode 100755
index 00000000..06bb57af
--- /dev/null
+++ b/samples/monsterdata.json
@@ -0,0 +1,9 @@
+{
+  pos: {
+    x: 1,
+    y: 2,
+    z: 3
+  },
+  hp: 80,
+  name: "MyMonster"
+}
diff --git a/samples/sample_binary.cpp b/samples/sample_binary.cpp
new file mode 100755
index 00000000..92c4c58e
--- /dev/null
+++ b/samples/sample_binary.cpp
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "monster_generated.h"
+
+using namespace MyGame::Sample;
+
+// Example how to use FlatBuffers to create and read binary buffers.
+
+int main(int argc, const char *argv[]) {
+  // Build up a serialized buffer algorithmically:
+  flatbuffers::FlatBufferBuilder builder;
+
+  auto vec = Vec3(1, 2, 3);
+
+  auto name = builder.CreateString("MyMonster");
+
+  unsigned char inv_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+  auto inventory = builder.CreateVector(inv_data, 10);
+
+  // Shortcut for creating monster with all fields set:
+  auto mloc = CreateMonster(builder, &vec, 150, 80, name, inventory,
+                            Color_Blue);
+
+  builder.Finish(mloc);
+  // We now have a FlatBuffer we can store or send somewhere.
+
+  // ** file/network code goes here :) **
+  // access builder.GetBufferPointer() for builder.GetSize() bytes
+
+  // Instead, we're going to access it straight away.
+  // Get access to the root:
+  auto monster = GetMonster(builder.GetBufferPointer());
+
+  assert(monster->hp() == 80);
+  assert(monster->mana() == 150);  // default
+  assert(!strcmp(monster->name()->c_str(), "MyMonster"));
+
+  auto pos = monster->pos();
+  assert(pos);
+  assert(pos->z() == 3);
+
+  auto inv = monster->inventory();
+  assert(inv);
+  assert(inv->Get(9) == 9);
+}
+
diff --git a/samples/sample_text.cpp b/samples/sample_text.cpp
new file mode 100755
index 00000000..b4d2d251
--- /dev/null
+++ b/samples/sample_text.cpp
@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
+
+#include "monster_generated.h"
+
+using namespace MyGame::Sample;
+
+// This is an example of parsing text straight into a buffer and then
+// generating flatbuffer (JSON) text from the buffer.
+int main(int argc, const char *argv[]) {
+  // load FlatBuffer schema (.fbs) and JSON from disk
+  std::string schemafile;
+  std::string jsonfile;
+  bool ok = flatbuffers::LoadFile("samples/monster.fbs", false, &schemafile) &&
+            flatbuffers::LoadFile("samples/monsterdata.json", false, &jsonfile);
+  if (!ok) {
+    printf("couldn't load files!\n");
+    return 1;
+  }
+
+  // parse schema first, so we can use it to parse the data after
+  flatbuffers::Parser parser;
+  ok = parser.Parse(schemafile.c_str()) &&
+       parser.Parse(jsonfile.c_str());
+  assert(ok);
+
+  // here, parser.builder_ contains a binary buffer that is the parsed data.
+
+  // to ensure it is correct, we now generate text back from the binary,
+  // and compare the two:
+  std::string jsongen;
+  GenerateText(parser, parser.builder_.GetBufferPointer(), 2, &jsongen);
+
+  if (jsongen != jsonfile) {
+    printf("%s----------------\n%s", jsongen.c_str(), jsonfile.c_str());
+  }
+}