Using flatbuffers struct as a key

Question

I am considering using flatbuffers' serialized struct as a key in a key-value store. Here is an example of the structs that I want to use as a key in rocksdb.

struct Foo {
  foo_id: int64;
  foo_type: int32;
}

I read the documentation and figured that the layout of a struct is deterministic. Does that mean it is suitable to be used as a key? If yes, how do I serialize a struct and deserialize it back. It seems like Table has API for serialization/deserialization but struct does not (?).

I tried serializing struct doing it as follows:

constexpr int key_size = sizeof(Foo);
using FooKey = std::array<char, key_size>;

FooKey get_foo_key(const Foo& foo_object) {
  FooKey key;
  std::memcpy(&key, &foo_object, key_size);
  return key;
}

const Foo* get_foo(const FooKey& key) {
  return reinterpret_cast<const Foo*>(&key);
}

I did some sanity checks and the above seems to work in my Ubuntu 18 docker image and is blazing fast. So my questions are as follows:

1. Is this a safe thing to do on a machine if it passes FLATBUFFERS_LITTLEENDIAN and uint8/char equivalence checks? Or are there any other checks needed?

2. Are there any other caveats that I should be aware of when doing it as demonstrated above?

Thanks in advance !

Answer 1

You don't actually need to go via std::array, the Foo struct is already a block of memory that is safe to copy or cast as you wish. It needs no serialization functions.

Like you said, that memory contains little endian data, so FLATBUFFERS_LITTLEENDIAN must pass. Actually even on a big endian machine you may copy these structures all you want, as long as you use the accessors to read the fields (which do a byteswap on access on big endian). The only thing that won't work on big endian is casting the struct to, say, an int64_t * to read the first field without using the accessor methods.

The other caveat to certain casting operations is strict aliasing, if you have that turned on certain casts may be undefined behavior.

Also note that in this example Foo will be 16 bytes in size on all platforms, because of alignment.