6.5.3 clean

examples/corelib/serialization/savegame/CMakeLists.txt

@@ -4,6 +4,10 @@
 cmake_minimum_required(VERSION 3.16)
 project(savegame LANGUAGES CXX)
 
+if (ANDROID)
+    message(FATAL_ERROR "This project cannot be built on Android.")
+endif()
+
 if(NOT DEFINED INSTALL_EXAMPLESDIR)
     set(INSTALL_EXAMPLESDIR "examples")
 endif()

examples/corelib/serialization/savegame/character.cpp

@@ -6,15 +6,10 @@
 #include <QMetaEnum>
 #include <QTextStream>
 
-Character::Character()
-    = default;
+Character::Character() = default;
 
-Character::Character(const QString &name,
-                     int level,
-                     Character::ClassType classType) :
-    mName(name),
-    mLevel(level),
-    mClassType(classType)
+Character::Character(const QString &name, int level, Character::ClassType classType)
+    : mName(name), mLevel(level), mClassType(classType)
 {
 }
 
@@ -48,35 +43,41 @@ void Character::setClassType(Character::ClassType classType)
     mClassType = classType;
 }
 
-//! [0]
-void Character::read(const QJsonObject &json)
+//! [fromJson]
+Character Character::fromJson(const QJsonObject &json)
 {
-    if (json.contains("name") && json["name"].isString())
-        mName = json["name"].toString();
+    Character result;
 
-    if (json.contains("level") && json["level"].isDouble())
-        mLevel = json["level"].toInt();
+    if (const QJsonValue v = json["name"]; v.isString())
+        result.mName = v.toString();
 
-    if (json.contains("classType") && json["classType"].isDouble())
-        mClassType = ClassType(json["classType"].toInt());
+    if (const QJsonValue v = json["level"]; v.isDouble())
+        result.mLevel = v.toInt();
+
+    if (const QJsonValue v = json["classType"]; v.isDouble())
+        result.mClassType = ClassType(v.toInt());
+
+    return result;
 }
-//! [0]
+//! [fromJson]
 
-//! [1]
-void Character::write(QJsonObject &json) const
+//! [toJson]
+QJsonObject Character::toJson() const
 {
+    QJsonObject json;
     json["name"] = mName;
     json["level"] = mLevel;
     json["classType"] = mClassType;
+    return json;
 }
-//! [1]
+//! [toJson]
 
-void Character::print(int indentation) const
+void Character::print(QTextStream &s, int indentation) const
 {
     const QString indent(indentation * 2, ' ');
-    QTextStream(stdout) << indent << "Name:\t" << mName << "\n";
-    QTextStream(stdout) << indent << "Level:\t" << mLevel << "\n";
+    const QString className = QMetaEnum::fromType<ClassType>().valueToKey(mClassType);
 
-    QString className = QMetaEnum::fromType<ClassType>().valueToKey(mClassType);
-    QTextStream(stdout) << indent << "Class:\t" << className << "\n";
+    s << indent << "Name:\t" << mName << "\n"
+      << indent << "Level:\t" << mLevel << "\n"
+      << indent << "Class:\t" << className << "\n";
 }

examples/corelib/serialization/savegame/character.h

@@ -8,15 +8,15 @@
 #include <QObject>
 #include <QString>
 
+QT_FORWARD_DECLARE_CLASS(QTextStream)
+
 //! [0]
 class Character
 {
     Q_GADGET
 
 public:
-    enum ClassType {
-        Warrior, Mage, Archer
-    };
+    enum ClassType { Warrior, Mage, Archer };
     Q_ENUM(ClassType)
 
     Character();
@@ -31,10 +31,11 @@ public:
     ClassType classType() const;
     void setClassType(ClassType classType);
 
-    void read(const QJsonObject &json);
-    void write(QJsonObject &json) const;
+    static Character fromJson(const QJsonObject &json);
+    QJsonObject toJson() const;
+
+    void print(QTextStream &s, int indentation = 0) const;
 
-    void print(int indentation = 0) const;
 private:
     QString mName;
     int mLevel = 0;

examples/corelib/serialization/savegame/doc/src/savegame.qdoc

@@ -3,7 +3,7 @@
 
 /*!
     \example serialization/savegame
-    \examplecategory {Input/Output}
+    \examplecategory {Data Processing & I/O}
     \title JSON Save Game Example
 
     \brief The JSON Save Game example demonstrates how to save and load a
@@ -11,11 +11,12 @@
 
     Many games provide save functionality, so that the player's progress through
     the game can be saved and loaded at a later time. The process of saving a
-    game generally involves serializing each game object's member variables
-    to a file. Many formats can be used for this purpose, one of which is JSON.
-    With QJsonDocument, you also have the ability to serialize a document in a
-    \l {RFC 7049} {CBOR} format, which is great if you
-    don't want the save file to be readable, or if you need to keep the file size down.
+    game generally involves serializing each game object's member variables to a
+    file. Many formats can be used for this purpose, one of which is JSON.  With
+    QJsonDocument, you also have the ability to serialize a document in a \l
+    {RFC 7049} {CBOR} format, which is great if you don't want the save file to
+    be easy to read (but see \l {Parsing and displaying CBOR data} for how it \e
+    can be read), or if you need to keep the file size down.
 
     In this example, we'll demonstrate how to save and load a simple game to
     and from JSON and binary formats.
@@ -25,45 +26,83 @@
     The Character class represents a non-player character (NPC) in our game, and
     stores the player's name, level, and class type.
 
-    It provides read() and write() functions to serialise its member variables.
+    It provides static fromJson() and non-static toJson() functions to
+    serialise itself.
+
+    \note This pattern (fromJson()/toJson()) works because QJsonObjects can be
+    constructed independent of an owning QJsonDocument, and because the data
+    types being (de)serialized here are value types, so can be copied. When
+    serializing to another format — for example XML or QDataStream, which require passing
+    a document-like object — or when the object identity is important (QObject
+    subclasses, for example), other patterns may be more suitable. See the
+    \l{xml/dombookmarks} and \l{xml/streambookmarks} examples for XML, and the
+    implementation of \l QListWidgetItem::read() and \l QListWidgetItem::write()
+    for idiomatic QDataStream serialization. The \c{print()} functions in this example
+    are good examples of QTextStream serialization, even though they, of course, lack
+    the deserialization side.
 
     \snippet serialization/savegame/character.h 0
 
-    Of particular interest to us are the read and write function
+    Of particular interest to us are the fromJson() and toJson() function
     implementations:
 
-    \snippet serialization/savegame/character.cpp 0
+    \snippet serialization/savegame/character.cpp fromJson
 
-    In the read() function, we assign Character's members values from the
-    QJsonObject argument. You can use either \l QJsonObject::operator[]() or
-    QJsonObject::value() to access values within the JSON object; both are
-    const functions and return QJsonValue::Undefined if the key is invalid. We
-    check if the keys are valid before attempting to read them with
-    QJsonObject::contains().
+    In the fromJson() function, we construct a local \c result Character object
+    and assign \c{result}'s members values from the QJsonObject argument. You
+    can use either \l QJsonObject::operator[]() or QJsonObject::value() to
+    access values within the JSON object; both are const functions and return
+    QJsonValue::Undefined if the key is invalid. In particular, the \c{is...}
+    functions (for example \l QJsonValue::isString(), \l
+    QJsonValue::isDouble()) return \c false for QJsonValue::Undefined, so we
+    can check for existence as well as the correct type in a single lookup.
 
-    \snippet serialization/savegame/character.cpp 1
+    If a value does not exist in the JSON object, or has the wrong type, we
+    don't write to the corresponding \c result member, either, thereby
+    preserving any values the default constructor may have set. This means
+    default values are centrally defined in one location (the default
+    constructor) and need not be repeated in serialisation code
+    (\l{https://en.wikipedia.org/wiki/Don%27t_repeat_yourself}{DRY}).
 
-    In the write() function, we do the reverse of the read() function; assign
-    values from the Character object to the JSON object. As with accessing
-    values, there are two ways to set values on a QJsonObject:
-    \l QJsonObject::operator[]() and QJsonObject::insert(). Both will override
-    any existing value at the given key.
+    Observe the use of
+    \l{https://en.cppreference.com/w/cpp/language/if#If_statements_with_initializer}
+    {C++17 if-with-initializer} to separate scoping and checking of the variable \c v.
+    This means we can keep the variable name short, because its scope is limited.
 
-    Next up is the Level class:
+    Compare that to the naïve approach using \c QJsonObject::contains():
+
+    \badcode
+    if (json.contains("name") && json["name"].isString())
+        result.mName = json["name"].toString();
+    \endcode
+
+    which, beside being less readable, requires a total of three lookups (no,
+    the compiler will \e not optimize these into one), so is three times
+    slower and repeats \c{"name"} three times (violating the DRY principle).
+
+    \snippet serialization/savegame/character.cpp toJson
+
+    In the toJson() function, we do the reverse of the fromJson() function;
+    assign values from the Character object to a new JSON object we then
+    return. As with accessing values, there are two ways to set values on a
+    QJsonObject: \l QJsonObject::operator[]() and \l QJsonObject::insert().
+    Both will override any existing value at the given key.
+
+    \section1 The Level Class
 
     \snippet serialization/savegame/level.h 0
 
-    We want to have several levels in our game, each with several NPCs, so we
-    keep a QList of Character objects. We also provide the familiar read() and
-    write() functions.
+    We want the levels in our game to each each have several NPCs, so we keep a QList
+    of Character objects. We also provide the familiar fromJson() and toJson()
+    functions.
 
-    \snippet serialization/savegame/level.cpp 0
+    \snippet serialization/savegame/level.cpp fromJson
 
-    Containers can be written and read to and from JSON using QJsonArray. In our
+    Containers can be written to and read from JSON using QJsonArray. In our
     case, we construct a QJsonArray from the value associated with the key
     \c "npcs". Then, for each QJsonValue element in the array, we call
-    toObject() to get the Character's JSON object. The Character object can then
-    read their JSON and be appended to our NPC array.
+    toObject() to get the Character's JSON object. Character::fromJson() can
+    then turn that QJSonObject into a Character object to append to our NPC array.
 
     \note \l{Container Classes}{Associate containers} can be written by storing
     the key in each value object (if it's not already). With this approach, the
@@ -71,11 +110,13 @@
     element is used as the key to construct the container when reading it back
     in.
 
-    \snippet serialization/savegame/level.cpp 1
+    \snippet serialization/savegame/level.cpp toJson
 
-    Again, the write() function is similar to the read() function, except
+    Again, the toJson() function is similar to the fromJson() function, except
     reversed.
 
+    \section1 The Game Class
+
     Having established the Character and Level classes, we can move on to
     the Game class:
 
@@ -87,26 +128,43 @@
     Next, we provide accessors for the player and levels. We then expose three
     functions: newGame(), saveGame() and loadGame().
 
-    The read() and write() functions are used by saveGame() and loadGame().
+    The read() and toJson() functions are used by saveGame() and loadGame().
 
-    \snippet serialization/savegame/game.cpp 0
+    \div{class="admonition note"}\b{Note:}
+        Despite \c Game being a value class, we assume that the author wants a game to have
+        identity, much like your main window would have. We therefore don't use a
+        static fromJson() function, which would create a new object, but a read()
+        function we can call on existing objects. There's a 1:1 correspondence
+        between read() and fromJson(), in that one can be implemented in terms of
+        the other:
+
+        \code
+        void read(const QJsonObject &json) { *this = fromJson(json); }
+        static Game fromObject(const QJsonObject &json) { Game g; g.read(json); return g; }
+        \endcode
+
+        We just use what's more convenient for callers of the functions.
+    \enddiv
+
+    \snippet serialization/savegame/game.cpp newGame
 
     To setup a new game, we create the player and populate the levels and their
     NPCs.
 
-    \snippet serialization/savegame/game.cpp 1
+    \snippet serialization/savegame/game.cpp read
 
-    The first thing we do in the read() function is tell the player to read
-    itself. We then clear the level array so that calling loadGame() on the
-    same Game object twice doesn't result in old levels hanging around.
+    The read() function starts by replacing the player with the
+    one read from JSON. We then clear() the level array so that calling
+    loadGame() on the same Game object twice doesn't result in old levels
+    hanging around.
 
     We then populate the level array by reading each Level from a QJsonArray.
 
-    \snippet serialization/savegame/game.cpp 2
+    \snippet serialization/savegame/game.cpp toJson
 
-    We write the game to JSON similarly to how we write Level.
+    Writing the game to JSON is similar to writing a level.
 
-    \snippet serialization/savegame/game.cpp 3
+    \snippet serialization/savegame/game.cpp loadGame
 
     When loading a saved game in loadGame(), the first thing we do is open the
     save file based on which format it was saved to; \c "save.json" for JSON,
@@ -120,14 +178,16 @@
     After constructing the QJsonDocument, we instruct the Game object to read
     itself and then return \c true to indicate success.
 
-    \snippet serialization/savegame/game.cpp 4
+    \snippet serialization/savegame/game.cpp saveGame
 
     Not surprisingly, saveGame() looks very much like loadGame(). We determine
     the file extension based on the format, print a warning and return \c false
     if the opening of the file fails. We then write the Game object to a
-    QJsonDocument, and call either QJsonDocument::toJson() or to
-    QJsonDocument::toBinaryData() to save the game, depending on which format
-    was specified.
+    QJsonObject. To save the game in the format that was specified, we
+    convert the JSON object into either a QJsonDocument for a subsequent
+    QJsonDocument::toJson() call, or a QCborValue for QCborValue::toCbor().
+
+    \section1 Tying It All Together
 
     We are now ready to enter main():
 

examples/corelib/serialization/savegame/game.cpp

@@ -11,6 +11,8 @@
 #include <QRandomGenerator>
 #include <QTextStream>
 
+using namespace Qt::StringLiterals;
+
 Character Game::player() const
 {
     return mPlayer;
@@ -21,52 +23,45 @@ QList<Level> Game::levels() const
     return mLevels;
 }
 
-//! [0]
+//! [newGame]
 void Game::newGame()
 {
     mPlayer = Character();
-    mPlayer.setName(QStringLiteral("Hero"));
+    mPlayer.setName("Hero"_L1);
     mPlayer.setClassType(Character::Archer);
     mPlayer.setLevel(QRandomGenerator::global()->bounded(15, 21));
 
     mLevels.clear();
     mLevels.reserve(2);
 
-    Level village(QStringLiteral("Village"));
+    Level village("Village"_L1);
     QList<Character> villageNpcs;
     villageNpcs.reserve(2);
-    villageNpcs.append(Character(QStringLiteral("Barry the Blacksmith"),
-                                 QRandomGenerator::global()->bounded(8, 11),
-                                 Character::Warrior));
-    villageNpcs.append(Character(QStringLiteral("Terry the Trader"),
-                                 QRandomGenerator::global()->bounded(6, 8),
-                                 Character::Warrior));
+    villageNpcs.append(Character("Barry the Blacksmith"_L1,
+                                 QRandomGenerator::global()->bounded(8, 11), Character::Warrior));
+    villageNpcs.append(Character("Terry the Trader"_L1,
+                                 QRandomGenerator::global()->bounded(6, 8), Character::Warrior));
     village.setNpcs(villageNpcs);
     mLevels.append(village);
 
-    Level dungeon(QStringLiteral("Dungeon"));
+    Level dungeon("Dungeon"_L1);
     QList<Character> dungeonNpcs;
     dungeonNpcs.reserve(3);
-    dungeonNpcs.append(Character(QStringLiteral("Eric the Evil"),
-                                 QRandomGenerator::global()->bounded(18, 26),
-                                 Character::Mage));
-    dungeonNpcs.append(Character(QStringLiteral("Eric's Left Minion"),
-                                 QRandomGenerator::global()->bounded(5, 7),
-                                 Character::Warrior));
-    dungeonNpcs.append(Character(QStringLiteral("Eric's Right Minion"),
-                                 QRandomGenerator::global()->bounded(4, 9),
-                                 Character::Warrior));
+    dungeonNpcs.append(Character("Eric the Evil"_L1,
+                                 QRandomGenerator::global()->bounded(18, 26), Character::Mage));
+    dungeonNpcs.append(Character("Eric's Left Minion"_L1,
+                                 QRandomGenerator::global()->bounded(5, 7), Character::Warrior));
+    dungeonNpcs.append(Character("Eric's Right Minion"_L1,
+                                 QRandomGenerator::global()->bounded(4, 9), Character::Warrior));
     dungeon.setNpcs(dungeonNpcs);
     mLevels.append(dungeon);
 }
-//! [0]
+//! [newGame]
 
-//! [3]
+//! [loadGame]
 bool Game::loadGame(Game::SaveFormat saveFormat)
 {
-    QFile loadFile(saveFormat == Json
-        ? QStringLiteral("save.json")
-        : QStringLiteral("save.dat"));
+    QFile loadFile(saveFormat == Json ? "save.json"_L1 : "save.dat"_L1);
 
     if (!loadFile.open(QIODevice::ReadOnly)) {
         qWarning("Couldn't open save file.");
@@ -76,85 +71,72 @@ bool Game::loadGame(Game::SaveFormat saveFormat)
     QByteArray saveData = loadFile.readAll();
 
     QJsonDocument loadDoc(saveFormat == Json
-        ? QJsonDocument::fromJson(saveData)
-        : QJsonDocument(QCborValue::fromCbor(saveData).toMap().toJsonObject()));
+                          ? QJsonDocument::fromJson(saveData)
+                          : QJsonDocument(QCborValue::fromCbor(saveData).toMap().toJsonObject()));
 
     read(loadDoc.object());
 
-    QTextStream(stdout) << "Loaded save for "
-                        << loadDoc["player"]["name"].toString()
-                        << " using "
-                        << (saveFormat != Json ? "CBOR" : "JSON") << "...\n";
+    QTextStream(stdout) << "Loaded save for " << loadDoc["player"]["name"].toString()
+                        << " using " << (saveFormat != Json ? "CBOR" : "JSON") << "...\n";
     return true;
 }
-//! [3]
+//! [loadGame]
 
-//! [4]
+//! [saveGame]
 bool Game::saveGame(Game::SaveFormat saveFormat) const
 {
-    QFile saveFile(saveFormat == Json
-        ? QStringLiteral("save.json")
-        : QStringLiteral("save.dat"));
+    QFile saveFile(saveFormat == Json ? "save.json"_L1 : "save.dat"_L1);
 
     if (!saveFile.open(QIODevice::WriteOnly)) {
         qWarning("Couldn't open save file.");
         return false;
     }
 
-    QJsonObject gameObject;
-    write(gameObject);
-    saveFile.write(saveFormat == Json
-        ? QJsonDocument(gameObject).toJson()
-        : QCborValue::fromJsonValue(gameObject).toCbor());
+    QJsonObject gameObject = toJson();
+    saveFile.write(saveFormat == Json ? QJsonDocument(gameObject).toJson()
+                                      : QCborValue::fromJsonValue(gameObject).toCbor());
 
     return true;
 }
-//! [4]
+//! [saveGame]
 
-//! [1]
+//! [read]
 void Game::read(const QJsonObject &json)
 {
-    if (json.contains("player") && json["player"].isObject())
-        mPlayer.read(json["player"].toObject());
+    if (const QJsonValue v = json["player"]; v.isObject())
+        mPlayer = Character::fromJson(v.toObject());
 
-    if (json.contains("levels") && json["levels"].isArray()) {
-        QJsonArray levelArray = json["levels"].toArray();
+    if (const QJsonValue v = json["levels"]; v.isArray()) {
+        const QJsonArray levels = v.toArray();
         mLevels.clear();
-        mLevels.reserve(levelArray.size());
-        for (const QJsonValue &v : levelArray) {
-            QJsonObject levelObject = v.toObject();
-            Level level;
-            level.read(levelObject);
-            mLevels.append(level);
-        }
+        mLevels.reserve(levels.size());
+        for (const QJsonValue &level : levels)
+            mLevels.append(Level::fromJson(level.toObject()));
     }
 }
-//! [1]
+//! [read]
 
-//! [2]
-void Game::write(QJsonObject &json) const
+//! [toJson]
+QJsonObject Game::toJson() const
 {
-    QJsonObject playerObject;
-    mPlayer.write(playerObject);
-    json["player"] = playerObject;
+    QJsonObject json;
+    json["player"] = mPlayer.toJson();
 
-    QJsonArray levelArray;
-    for (const Level &level : mLevels) {
-        QJsonObject levelObject;
-        level.write(levelObject);
-        levelArray.append(levelObject);
-    }
-    json["levels"] = levelArray;
+    QJsonArray levels;
+    for (const Level &level : mLevels)
+        levels.append(level.toJson());
+    json["levels"] = levels;
+    return json;
 }
-//! [2]
+//! [toJson]
 
-void Game::print(int indentation) const
+void Game::print(QTextStream &s, int indentation) const
 {
     const QString indent(indentation * 2, ' ');
-    QTextStream(stdout) << indent << "Player\n";
-    mPlayer.print(indentation + 1);
+    s << indent << "Player\n";
+    mPlayer.print(s, indentation + 1);
 
-    QTextStream(stdout) << indent << "Levels\n";
+    s << indent << "Levels\n";
     for (const Level &level : mLevels)
-        level.print(indentation + 1);
+        level.print(s, indentation + 1);
 }

examples/corelib/serialization/savegame/game.h

@@ -10,13 +10,13 @@
 #include <QJsonObject>
 #include <QList>
 
+QT_FORWARD_DECLARE_CLASS(QTextStream)
+
 //! [0]
 class Game
 {
 public:
-    enum SaveFormat {
-        Json, Binary
-    };
+    enum SaveFormat { Json, Binary };
 
     Character player() const;
     QList<Level> levels() const;
@@ -26,9 +26,10 @@ public:
     bool saveGame(SaveFormat saveFormat) const;
 
     void read(const QJsonObject &json);
-    void write(QJsonObject &json) const;
+    QJsonObject toJson() const;
+
+    void print(QTextStream &s, int indentation = 0) const;
 
-    void print(int indentation = 0) const;
 private:
     Character mPlayer;
     QList<Level> mLevels;

examples/corelib/serialization/savegame/level.cpp

@@ -6,9 +6,7 @@
 #include <QJsonArray>
 #include <QTextStream>
 
-Level::Level(const QString &name) : mName(name)
-{
-}
+Level::Level(const QString &name) : mName(name) { }
 
 QString Level::name() const
 {
@@ -25,46 +23,43 @@ void Level::setNpcs(const QList<Character> &npcs)
     mNpcs = npcs;
 }
 
-//! [0]
-void Level::read(const QJsonObject &json)
+//! [fromJson]
+Level Level::fromJson(const QJsonObject &json)
 {
-    if (json.contains("name") && json["name"].isString())
-        mName = json["name"].toString();
+    Level result;
 
-    if (json.contains("npcs") && json["npcs"].isArray()) {
-        QJsonArray npcArray = json["npcs"].toArray();
-        mNpcs.clear();
-        mNpcs.reserve(npcArray.size());
-        for (const QJsonValue &v : npcArray) {
-            QJsonObject npcObject = v.toObject();
-            Character npc;
-            npc.read(npcObject);
-            mNpcs.append(npc);
-        }
+    if (const QJsonValue v = json["name"]; v.isString())
+        result.mName = v.toString();
+
+    if (const QJsonValue v = json["npcs"]; v.isArray()) {
+        const QJsonArray npcs = v.toArray();
+        result.mNpcs.reserve(npcs.size());
+        for (const QJsonValue &npc : npcs)
+            result.mNpcs.append(Character::fromJson(npc.toObject()));
     }
-}
-//! [0]
 
-//! [1]
-void Level::write(QJsonObject &json) const
+    return result;
+}
+//! [fromJson]
+
+//! [toJson]
+QJsonObject Level::toJson() const
 {
+    QJsonObject json;
     json["name"] = mName;
     QJsonArray npcArray;
-    for (const Character &npc : mNpcs) {
-        QJsonObject npcObject;
-        npc.write(npcObject);
-        npcArray.append(npcObject);
-    }
+    for (const Character &npc : mNpcs)
+        npcArray.append(npc.toJson());
     json["npcs"] = npcArray;
+    return json;
 }
-//! [1]
+//! [toJson]
 
-void Level::print(int indentation) const
+void Level::print(QTextStream &s, int indentation) const
 {
     const QString indent(indentation * 2, ' ');
-    QTextStream(stdout) << indent << "Name:\t" << mName << "\n";
 
-    QTextStream(stdout) << indent << "NPCs:\n";
+    s << indent << "Name:\t" << mName << "\n" << indent << "NPCs:\n";
     for (const Character &character : mNpcs)
-        character.print(2);
+        character.print(s, indentation + 1);
 }

examples/corelib/serialization/savegame/level.h

@@ -9,6 +9,8 @@
 #include <QJsonObject>
 #include <QList>
 
+QT_FORWARD_DECLARE_CLASS(QTextStream)
+
 //! [0]
 class Level
 {
@@ -21,10 +23,11 @@ public:
     QList<Character> npcs() const;
     void setNpcs(const QList<Character> &npcs);
 
-    void read(const QJsonObject &json);
-    void write(QJsonObject &json) const;
+    static Level fromJson(const QJsonObject &json);
+    QJsonObject toJson() const;
+
+    void print(QTextStream &s, int indentation = 0) const;
 
-    void print(int indentation = 0) const;
 private:
     QString mName;
     QList<Character> mNpcs;

examples/corelib/serialization/savegame/main.cpp

@@ -17,9 +17,9 @@ int main(int argc, char *argv[])
 
     const QStringList args = QCoreApplication::arguments();
     const bool newGame
-            = args.size() <= 1 || QString::compare(args[1], "load"_L1, Qt::CaseInsensitive) == 0;
+            = args.size() <= 1 || QString::compare(args[1], "load"_L1, Qt::CaseInsensitive) != 0;
     const bool json
-            = args.size() <= 2 || QString::compare(args[2], "binary"_L1, Qt::CaseInsensitive) == 0;
+            = args.size() <= 2 || QString::compare(args[2], "binary"_L1, Qt::CaseInsensitive) != 0;
 
     Game game;
     if (newGame)
@@ -29,8 +29,9 @@ int main(int argc, char *argv[])
     // Game is played; changes are made...
 //! [0]
 //! [1]
-    QTextStream(stdout) << "Game ended in the following state:\n";
-    game.print();
+    QTextStream s(stdout);
+    s << "Game ended in the following state:\n";
+    game.print(s);
     if (!game.saveGame(json ? Game::Json : Game::Binary))
         return 1;