I have an enum class called State in my game. How can I serialize and deserialize variables of this enum class type using cereal?

Question

Ryan McCombe · Accepted Answer

To serialize and deserialize variables of an enum class type using cereal, you can follow these steps:

Step 1: Include the necessary cereal headers:

1#include <cereal/archives/binary.hpp>
2#include <cereal/types/utility.hpp>

Step 2: Define your enum class:

1enum class State : std::uint8_t {
2  Idle,
3  Walking,
4  Running,
5  Jumping
6};

Step 3: Provide a serialization function for your enum class:

1template <class Archive>
2void serialize(Archive& ar, State& state) {
3  std::uint8_t value = static_cast<
4    std::uint8_t>(state);
5  ar(value);
6  state = static_cast<State>(value);
7}

This function converts the enum class to its underlying type (std::uint8_t in this case) for serialization and deserialization.

Step 4: Use the serialize function when serializing and deserializing objects that contain the enum class:

1class Player {
2 public:
3  // ...
4
5 private:
6  friend class cereal::access;
7
8  std::string name;
9  State state;
10
11  template <class Archive>
12  void serialize(Archive& ar) {
13    ar(name);
14    // Use the serialization function for State
15    ::serialize(ar, state);
16  }
17};

Note the use of the scope resolution operator :: to differentiate the serialize function for PlayerState from the member function serialize of the Player class.

Step 5: Serialize and deserialize objects containing the enum class as usual:

1#include <fstream>
2
3int main() {
4  // Serialization
5  Player player("Alice", PlayerState::Running);
6  std::ofstream outputFile("player.dat");
7  cereal::BinaryOutputArchive outputArchive(
8    outputFile);
9  outputArchive(player);
10
11  // Deserialization
12  Player deserializedPlayer;
13  std::ifstream inputFile("player.dat");
14  cereal::BinaryInputArchive inputArchive(
15    inputFile);
16  inputArchive(deserializedPlayer);
17}

By providing a serialization function for your enum class and using it when serializing and deserializing objects containing the enum class, cereal will be able to handle the serialization and deserialization of enum class variables correctly.

A complete example is available here:

1#include <cereal/archives/binary.hpp>
2#include <cereal/types/utility.hpp>
3#include <cereal/types/string.hpp>
4#include <fstream>
5#include <iostream>
6
7enum class State : std::uint8_t {
8  Idle, Walking, Running, Jumping };
9
10template <class Archive>
11void serialize(Archive& ar, State& state) {
12  std::uint8_t value = static_cast<
13    std::uint8_t>(state);
14  ar(value);
15  state = static_cast<State>(value);
16}
17
18class Player {
19 public:
20  Player() = default;
21  Player(const std::string& name, State state)
22      : name(name), state(state) {}
23
24  std::string name;
25  State state;
26
27 private:
28  friend class cereal::access;
29
30  template <class Archive>
31  void serialize(Archive& ar) {
32    ar(name);
33    ::serialize(ar, state);
34  }
35};
36
37int main() {
38  // Serialization
39  Player player("Alice", State::Running);
40  {
41    std::ofstream outputFile("player.dat");
42    cereal::BinaryOutputArchive outputArchive(
43      outputFile);
44    outputArchive(player);
45  }
46
47  // Deserialization
48  Player loadedPlayer;
49  {
50    std::ifstream inputFile("player.dat");
51    cereal::BinaryInputArchive inputArchive(
52      inputFile);
53    inputArchive(loadedPlayer);
54  }
55
56  std::cout << "Deserialized Player:\n";
57  std::cout << "Name: "
58    << loadedPlayer.name << "\n";
59
60  if (loadedPlayer.state == State::Running) {
61    std::cout << "State: Running";
62  }
63}

1Deserialized Player:
2Name: Alice
3State: Running

Binary Serialization using Cereal

Serializing Enum Classes with Cereal

Binary Serialization using Cereal

Professional C++

Questions & Answers