FlatBuffer Startup

namespace MyGame.Sample;

enum Color:byte { Red = 0, Green, Blue = 2 }

union Equipment { Weapon } // Optionally add more tables

struct Vec3 {
	x: float; // Here default value is unspecified, given it as 0
	y: float;
	z: float;
}

table Monster {
	pos: Vec3; // Struct
	mana: short = 150;
	hp: short = 100;
	name: string;
	friendly: bool = false (deprecated); // Will not genenate access function for deprecated field
	inventory: [ubyte]; // Vector of scalars
	color: Color = Blue; // Enum
	weapons: [Weapon]; // Vector of tables
	equipped:Equipment; // Union
	path: [Vec3]; // Vector of struct
}

table Weapon {
	name: string;
	damage: short;
}

// What will be the root table for the serialized data
root_type Monster;

void SerializeMonster(uint8_t *&buf, int &size) {
  flatbuffers::FlatBufferBuilder builder(1024);

  /* Use basic builder to create all fields in monster */
  auto weapon_one_name = builder.CreateString("Sword");
  short weapon_one_damage = 3;

  auto weapon_two_name = builder.CreateString("Axe");
  short weapon_two_damage = 5;

  auto sword = CreateWeapon(builder, weapon_one_name, weapon_one_damage);
  auto axe = CreateWeapon(builder, weapon_two_name, weapon_two_damage);

  auto name = builder.CreateString("Orc");
  unsigned char treasure[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  auto inventory = builder.CreateVector(treasure, 10);

  std::vector<flatbuffers::Offset<Weapon>> weapon_vector;
  weapon_vector.push_back(sword);
  weapon_vector.push_back(axe);
  auto weapons = builder.CreateVector(weapon_vector);

  Vec3 points[] = {Vec3(1.0f, 2.0f, 3.0f), Vec3(4.0f, 5.0f, 6.0f)};
  auto path = builder.CreateVectorOfStructs(points, 2);

  auto position = Vec3(1.0f, 2.0f, 3.0f);

  int hp = 300;
  int mana = 150;

  /* Create Monster */
  // Usage 1：set all fileds at once
//  auto orc = CreateMonster(builder, &position, mana, hp, name,
//                           inventory, Color_Red, weapons,
//                           Equipment_Weapon, axe.Union(), path);

  // Usage 2: set specified filed as needed
  MonsterBuilder monster_builder(builder);
  monster_builder.add_pos(&position);
  monster_builder.add_hp(hp);
  monster_builder.add_name(name);
  monster_builder.add_mana(mana);
  monster_builder.add_inventory(inventory);
  monster_builder.add_color(Color_Red);
  monster_builder.add_weapons(weapons);
  monster_builder.add_equipped_type(Equipment_Weapon);
  monster_builder.add_equipped(axe.Union());
  monster_builder.add_path(path);
  auto orc = monster_builder.Finish();

  /* Invoke Finish() to end the serializing procedure. */
  builder.Finish(orc);

  /* Get the serializing result: a byte buffer. */
  buf = builder.GetBufferPointer();
  size = builder.GetSize();
}

void DeserializeMonster(const uint8_t *buf) {
	/* Get deserialized root object: monster *//
	auto monster = GetMonster(buf);

  /* Get each field of monster */
  auto pos = monster->pos();
  auto hp = monster->hp();
  auto name = monster->name();
  auto mana = monster->mana();
  auto inventory = monster->inventory();
  auto color = monster->color();
  auto weapons = monster->weapons();
  auto equipment_type = monster->equipped_type();
  auto path = monster->path();

  /* Access each field and print them */
  cout << "pos: { x: " << pos->x() << ", y: " << pos->y() << ", z: " << pos->z() << " }" << endl;
  cout << "hp: " << hp << endl;
  cout << "name: " << name->str() << endl;
  cout << "mana: " << mana << endl;

  cout << "inventory: { ";
  for (decltype(inventory->size()) i = 0; i < inventory->size(); i++) {
    cout << static_cast<uint32_t>((*inventory)[i]);
    cout << (i < inventory->size() - 1 ?  ", " : " ");
  }
  cout << "}" << endl;

  cout << "color: " << EnumNameColor(color) << endl;
  cout << "weapons: { ";
  for (decltype(weapons->size()) i = 0; i < weapons->size(); i++) {
    const auto &weapon = (*weapons)[i];
    cout << "{name: " << weapon->name()->str() << ", damage: " << weapon->damage() << "}";
    cout << (i < weapons->size() - 1 ?  ", " : " ");
  }
  cout << "}" << endl;

  cout << "equipment_type: " << EnumNameEquipment(equipment_type) << endl;
  if (equipment_type == MyGame::Sample::Equipment_Weapon) {
    auto equipped_weapon = monster->equipped_as_Weapon();
    cout << "equipped: weapon {name: " << equipped_weapon->name()->str() << ", damage: " << equipped_weapon->damage() << "}";
  }
  cout << "}" << endl;

  cout << "path: {";
  for (decltype(path->size()) i = 0; i < path->size(); i++) {
    const auto &path_elem = (*path)[i];

    cout << "{ pos: x: " << path_elem->x() << ", y: " << path_elem->y() << ", z: " << path_elem->z() << " }";
    cout << (i < path->size() - 1 ?  ", " : " ");
  }
  cout << "}" << endl;
}

Serialize Monster, buf: 0x7f77ae008b3c, size: 196
Deserialize Monster:
pos: { x: 1, y: 2, z: 3 }
hp: 300
name: Orc
mana: 150
inventory: { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
color: Red
weapons: { {name: Sword, damage: 3}, {name: Axe, damage: 5} }
equipment_type: Weapon
equipped: weapon {name: Axe, damage: 5}}
path: {{ pos: x: 1, y: 2, z: 3 }, { pos: x: 4, y: 5, z: 6 } }