From 26a30738a4fa4e92300821fd761764ec8df2dcf2 Mon Sep 17 00:00:00 2001 From: Wouter van Oortmerssen Date: Mon, 27 Jan 2014 16:52:49 -0800 Subject: Initial commit of the FlatBuffers code. Change-Id: I4c9f0f722490b374257adb3fec63e44ae93da920 Tested: using VS2010 / Xcode / gcc on Linux. --- samples/monster.fbs | 25 +++++++++++++ samples/monster_generated.h | 88 +++++++++++++++++++++++++++++++++++++++++++++ samples/monsterdata.json | 9 +++++ samples/sample_binary.cpp | 62 ++++++++++++++++++++++++++++++++ samples/sample_text.cpp | 54 ++++++++++++++++++++++++++++ 5 files changed, 238 insertions(+) create mode 100755 samples/monster.fbs create mode 100755 samples/monster_generated.h create mode 100755 samples/monsterdata.json create mode 100755 samples/sample_binary.cpp create mode 100755 samples/sample_text.cpp (limited to 'samples') 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(4); } + int16_t mana() const { return GetField(6, 150); } + int16_t hp() const { return GetField(8, 100); } + const flatbuffers::String *name() const { return GetPointer(10); } + const flatbuffers::Vector *inventory() const { return GetPointer *>(14); } + int8_t color() const { return GetField(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(6, mana, 150); } + void add_hp(int16_t hp) { fbb_.AddElement(8, hp, 100); } + void add_name(flatbuffers::Offset name) { fbb_.AddOffset(10, name); } + void add_inventory(flatbuffers::Offset> inventory) { fbb_.AddOffset(14, inventory); } + void add_color(int8_t color) { fbb_.AddElement(16, color, 2); } + MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } + flatbuffers::Offset Finish() { return flatbuffers::Offset(fbb_.EndTable(start_, 7)); } +}; + +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const Vec3 *pos, int16_t mana, int16_t hp, flatbuffers::Offset name, flatbuffers::Offset> 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(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()); + } +} -- cgit v1.2.3