(se)SerializeString: Include max length in the name

This commit clarifies the maximal length of the serialized strings.
It will avoid accidental use of serializeString() when a larger string can be expected.

Removes unused Wide String serialization functions

diff --git a/src/client/content_cao.cpp b/src/client/content_cao.cpp
index 599139aa3715fcbc621c932d482db01306d0126c..71a9d4b545d8e1746a33e0466e12a493b8ac9835 100644 (file)
--- a/src/client/content_cao.cpp
+++ b/src/client/content_cao.cpp
@@ -371,7 +371,7 @@ void GenericCAO::processInitData(const std::string &data)
        }
 
        // PROTOCOL_VERSION >= 37
-       m_name = deSerializeString(is);
+       m_name = deSerializeString16(is);
        m_is_player = readU8(is);
        m_id = readU16(is);
        m_position = readV3F32(is);
@@ -381,7 +381,7 @@ void GenericCAO::processInitData(const std::string &data)
        const u8 num_messages = readU8(is);
 
        for (int i = 0; i < num_messages; i++) {
-               std::string message = deSerializeLongString(is);
+               std::string message = deSerializeString32(is);
                processMessage(message);
        }
 
@@ -1657,7 +1657,7 @@ void GenericCAO::processMessage(const std::string &data)
                rot_translator.update(m_rotation, false, update_interval);
                updateNodePos();
        } else if (cmd == AO_CMD_SET_TEXTURE_MOD) {
-               std::string mod = deSerializeString(is);
+               std::string mod = deSerializeString16(is);
 
                // immediately reset a engine issued texture modifier if a mod sends a different one
                if (m_reset_textures_timer > 0) {
@@ -1735,7 +1735,7 @@ void GenericCAO::processMessage(const std::string &data)
                m_animation_speed = readF32(is);
                updateAnimationSpeed();
        } else if (cmd == AO_CMD_SET_BONE_POSITION) {
-               std::string bone = deSerializeString(is);
+               std::string bone = deSerializeString16(is);
                v3f position = readV3F32(is);
                v3f rotation = readV3F32(is);
                m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
@@ -1743,7 +1743,7 @@ void GenericCAO::processMessage(const std::string &data)
                // updateBonePosition(); now called every step
        } else if (cmd == AO_CMD_ATTACH_TO) {
                u16 parent_id = readS16(is);
-               std::string bone = deSerializeString(is);
+               std::string bone = deSerializeString16(is);
                v3f position = readV3F32(is);
                v3f rotation = readV3F32(is);
 
@@ -1793,7 +1793,7 @@ void GenericCAO::processMessage(const std::string &data)
                int armor_groups_size = readU16(is);
                for(int i=0; i<armor_groups_size; i++)
                {
-                       std::string name = deSerializeString(is);
+                       std::string name = deSerializeString16(is);
                        int rating = readS16(is);
                        m_armor_groups[name] = rating;
                }

diff --git a/src/content_nodemeta.cpp b/src/content_nodemeta.cpp
index fc2859d27ac0d891a8134c4a04f56925d7094a91..39743c11f73e76f3dac64547d1443a9b5a4d70c6 100644 (file)
--- a/src/content_nodemeta.cpp
+++ b/src/content_nodemeta.cpp
@@ -43,26 +43,26 @@ static bool content_nodemeta_deserialize_legacy_body(
        if(id == NODEMETA_GENERIC) // GenericNodeMetadata (0.4-dev)
        {
                meta->getInventory()->deSerialize(is);
-               deSerializeLongString(is);  // m_text
-               deSerializeString(is);  // m_owner
+               deSerializeString32(is);  // m_text
+               deSerializeString16(is);  // m_owner
 
-               meta->setString("infotext",deSerializeString(is));
-               meta->setString("formspec",deSerializeString(is));
+               meta->setString("infotext",deSerializeString16(is));
+               meta->setString("formspec",deSerializeString16(is));
                readU8(is);  // m_allow_text_input
                readU8(is);  // m_allow_removal
                readU8(is);  // m_enforce_owner
 
                int num_vars = readU32(is);
                for(int i=0; i<num_vars; i++){
-                       std::string name = deSerializeString(is);
-                       std::string var = deSerializeLongString(is);
+                       std::string name = deSerializeString16(is);
+                       std::string var = deSerializeString32(is);
                        meta->setString(name, var);
                }
                return false;
        }
        else if(id == NODEMETA_SIGN) // SignNodeMetadata
        {
-               meta->setString("text", deSerializeString(is));
+               meta->setString("text", deSerializeString16(is));
                //meta->setString("infotext","\"${text}\"");
                meta->setString("infotext",
                                std::string("\"") + meta->getString("text") + "\"");
@@ -87,7 +87,7 @@ static bool content_nodemeta_deserialize_legacy_body(
        }
        else if(id == NODEMETA_LOCKABLE_CHEST) // LockingChestNodeMetadata
        {
-               meta->setString("owner", deSerializeString(is));
+               meta->setString("owner", deSerializeString16(is));
                meta->getInventory()->deSerialize(is);
 
                // Rename inventory list "0" to "main"
@@ -138,7 +138,7 @@ static bool content_nodemeta_deserialize_legacy_meta(
        s16 id = readS16(is);
 
        // Read data
-       std::string data = deSerializeString(is);
+       std::string data = deSerializeString16(is);
        std::istringstream tmp_is(data, std::ios::binary);
        return content_nodemeta_deserialize_legacy_body(tmp_is, id, meta);
 }

diff --git a/src/database/database-leveldb.cpp b/src/database/database-leveldb.cpp
index 1976ae13dc11e0350c8d9da8c21bc5891bdc9cd8..73cd63f6d1de1e1c608f58c517896a525bda1c23 100644 (file)
--- a/src/database/database-leveldb.cpp
+++ b/src/database/database-leveldb.cpp
@@ -145,8 +145,8 @@ void PlayerDatabaseLevelDB::savePlayer(RemotePlayer *player)
        StringMap stringvars = sao->getMeta().getStrings();
        writeU32(os, stringvars.size());
        for (const auto &it : stringvars) {
-               os << serializeString(it.first);
-               os << serializeLongString(it.second);
+               os << serializeString16(it.first);
+               os << serializeString32(it.second);
        }
 
        player->inventory.serialize(os);
@@ -183,8 +183,8 @@ bool PlayerDatabaseLevelDB::loadPlayer(RemotePlayer *player, PlayerSAO *sao)
 
        u32 attribute_count = readU32(is);
        for (u32 i = 0; i < attribute_count; i++) {
-               std::string name = deSerializeString(is);
-               std::string value = deSerializeLongString(is);
+               std::string name = deSerializeString16(is);
+               std::string value = deSerializeString32(is);
                sao->getMeta().setString(name, value);
        }
        sao->getMeta().setModified(false);
@@ -247,13 +247,13 @@ bool AuthDatabaseLevelDB::getAuth(const std::string &name, AuthEntry &res)
 
        res.id = 1;
        res.name = name;
-       res.password = deSerializeString(is);
+       res.password = deSerializeString16(is);
 
        u16 privilege_count = readU16(is);
        res.privileges.clear();
        res.privileges.reserve(privilege_count);
        for (u16 i = 0; i < privilege_count; i++) {
-               res.privileges.push_back(deSerializeString(is));
+               res.privileges.push_back(deSerializeString16(is));
        }
 
        res.last_login = readS64(is);
@@ -264,14 +264,14 @@ bool AuthDatabaseLevelDB::saveAuth(const AuthEntry &authEntry)
 {
        std::ostringstream os;
        writeU8(os, 1);
-       os << serializeString(authEntry.password);
+       os << serializeString16(authEntry.password);
 
        size_t privilege_count = authEntry.privileges.size();
        FATAL_ERROR_IF(privilege_count > U16_MAX,
                "Unsupported number of privileges");
        writeU16(os, privilege_count);
        for (const std::string &privilege : authEntry.privileges) {
-               os << serializeString(privilege);
+               os << serializeString16(privilege);
        }
 
        writeS64(os, authEntry.last_login);

diff --git a/src/itemdef.cpp b/src/itemdef.cpp
index 8e049282739000b2763f4ec5f3609eaaf6f918c1..df20bdf15c7efd40249f2d89c38ef8dd9e0c3d1f 100644 (file)
--- a/src/itemdef.cpp
+++ b/src/itemdef.cpp
@@ -128,10 +128,10 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
        u8 version = 6;
        writeU8(os, version);
        writeU8(os, type);
-       os << serializeString(name);
-       os << serializeString(description);
-       os << serializeString(inventory_image);
-       os << serializeString(wield_image);
+       os << serializeString16(name);
+       os << serializeString16(description);
+       os << serializeString16(inventory_image);
+       os << serializeString16(wield_image);
        writeV3F32(os, wield_scale);
        writeS16(os, stack_max);
        writeU8(os, usable);
@@ -143,25 +143,25 @@ void ItemDefinition::serialize(std::ostream &os, u16 protocol_version) const
                tool_capabilities->serialize(tmp_os, protocol_version);
                tool_capabilities_s = tmp_os.str();
        }
-       os << serializeString(tool_capabilities_s);
+       os << serializeString16(tool_capabilities_s);
 
        writeU16(os, groups.size());
        for (const auto &group : groups) {
-               os << serializeString(group.first);
+               os << serializeString16(group.first);
                writeS16(os, group.second);
        }
 
-       os << serializeString(node_placement_prediction);
+       os << serializeString16(node_placement_prediction);
 
        // Version from ContentFeatures::serialize to keep in sync
        sound_place.serialize(os, CONTENTFEATURES_VERSION);
        sound_place_failed.serialize(os, CONTENTFEATURES_VERSION);
 
        writeF32(os, range);
-       os << serializeString(palette_image);
+       os << serializeString16(palette_image);
        writeARGB8(os, color);
-       os << serializeString(inventory_overlay);
-       os << serializeString(wield_overlay);
+       os << serializeString16(inventory_overlay);
+       os << serializeString16(wield_overlay);
 }
 
 void ItemDefinition::deSerialize(std::istream &is)
@@ -175,16 +175,16 @@ void ItemDefinition::deSerialize(std::istream &is)
                throw SerializationError("unsupported ItemDefinition version");
 
        type = (enum ItemType)readU8(is);
-       name = deSerializeString(is);
-       description = deSerializeString(is);
-       inventory_image = deSerializeString(is);
-       wield_image = deSerializeString(is);
+       name = deSerializeString16(is);
+       description = deSerializeString16(is);
+       inventory_image = deSerializeString16(is);
+       wield_image = deSerializeString16(is);
        wield_scale = readV3F32(is);
        stack_max = readS16(is);
        usable = readU8(is);
        liquids_pointable = readU8(is);
 
-       std::string tool_capabilities_s = deSerializeString(is);
+       std::string tool_capabilities_s = deSerializeString16(is);
        if (!tool_capabilities_s.empty()) {
                std::istringstream tmp_is(tool_capabilities_s, std::ios::binary);
                tool_capabilities = new ToolCapabilities;
@@ -194,22 +194,22 @@ void ItemDefinition::deSerialize(std::istream &is)
        groups.clear();
        u32 groups_size = readU16(is);
        for(u32 i=0; i<groups_size; i++){
-               std::string name = deSerializeString(is);
+               std::string name = deSerializeString16(is);
                int value = readS16(is);
                groups[name] = value;
        }
 
-       node_placement_prediction = deSerializeString(is);
+       node_placement_prediction = deSerializeString16(is);
 
        // Version from ContentFeatures::serialize to keep in sync
        sound_place.deSerialize(is, CONTENTFEATURES_VERSION);
        sound_place_failed.deSerialize(is, CONTENTFEATURES_VERSION);
 
        range = readF32(is);
-       palette_image = deSerializeString(is);
+       palette_image = deSerializeString16(is);
        color = readARGB8(is);
-       inventory_overlay = deSerializeString(is);
-       wield_overlay = deSerializeString(is);
+       inventory_overlay = deSerializeString16(is);
+       wield_overlay = deSerializeString16(is);
 
        // If you add anything here, insert it primarily inside the try-catch
        // block to not need to increase the version.
@@ -521,14 +521,14 @@ class CItemDefManager: public IWritableItemDefManager
                        // Serialize ItemDefinition and write wrapped in a string
                        std::ostringstream tmp_os(std::ios::binary);
                        def->serialize(tmp_os, protocol_version);
-                       os << serializeString(tmp_os.str());
+                       os << serializeString16(tmp_os.str());
                }
 
                writeU16(os, m_aliases.size());
 
                for (const auto &it : m_aliases) {
-                       os << serializeString(it.first);
-                       os << serializeString(it.second);
+                       os << serializeString16(it.first);
+                       os << serializeString16(it.second);
                }
        }
        void deSerialize(std::istream &is)
@@ -543,7 +543,7 @@ class CItemDefManager: public IWritableItemDefManager
                for(u16 i=0; i<count; i++)
                {
                        // Deserialize a string and grab an ItemDefinition from it
-                       std::istringstream tmp_is(deSerializeString(is), std::ios::binary);
+                       std::istringstream tmp_is(deSerializeString16(is), std::ios::binary);
                        ItemDefinition def;
                        def.deSerialize(tmp_is);
                        // Register
@@ -552,8 +552,8 @@ class CItemDefManager: public IWritableItemDefManager
                u16 num_aliases = readU16(is);
                for(u16 i=0; i<num_aliases; i++)
                {
-                       std::string name = deSerializeString(is);
-                       std::string convert_to = deSerializeString(is);
+                       std::string name = deSerializeString16(is);
+                       std::string convert_to = deSerializeString16(is);
                        registerAlias(name, convert_to);
                }
        }

diff --git a/src/mapblock.cpp b/src/mapblock.cpp
index 5b755b7a645590793ff2cfb21a6da043f9a324cd..5fb6b221b36a86ac92c0596133a3eae4e35a334f 100644 (file)
--- a/src/mapblock.cpp
+++ b/src/mapblock.cpp
@@ -668,13 +668,13 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
                        // Ignore errors
                        try {
                                if (version <= 15) {
-                                       std::string data = deSerializeString(is);
+                                       std::string data = deSerializeString16(is);
                                        std::istringstream iss(data, std::ios_base::binary);
                                        content_nodemeta_deserialize_legacy(iss,
                                                &m_node_metadata, &m_node_timers,
                                                m_gamedef->idef());
                                } else {
-                                       //std::string data = deSerializeLongString(is);
+                                       //std::string data = deSerializeString32(is);
                                        std::ostringstream oss(std::ios_base::binary);
                                        decompressZlib(is, oss);
                                        std::istringstream iss(oss.str(), std::ios_base::binary);

diff --git a/src/mapgen/mg_schematic.cpp b/src/mapgen/mg_schematic.cpp
index ba102d9977de4f92d0984eb76575de6086b2a42a..dfd41470939b61ab545bd63d812736c4cd167a98 100644 (file)
--- a/src/mapgen/mg_schematic.cpp
+++ b/src/mapgen/mg_schematic.cpp
@@ -314,7 +314,7 @@ bool Schematic::deserializeFromMts(std::istream *is,
        //// Read node names
        u16 nidmapcount = readU16(ss);
        for (int i = 0; i != nidmapcount; i++) {
-               std::string name = deSerializeString(ss);
+               std::string name = deSerializeString16(ss);
 
                // Instances of "ignore" from v1 are converted to air (and instances
                // are fixed to have MTSCHEM_PROB_NEVER later on).
@@ -372,7 +372,7 @@ bool Schematic::serializeToMts(std::ostream *os,
 
        writeU16(ss, names.size()); // name count
        for (size_t i = 0; i != names.size(); i++)
-               ss << serializeString(names[i]); // node names
+               ss << serializeString16(names[i]); // node names
 
        // compressed bulk node data
        MapNode::serializeBulk(ss, SER_FMT_VER_HIGHEST_WRITE,

diff --git a/src/nameidmapping.cpp b/src/nameidmapping.cpp
index bd5bb1fc8ce71394c300f6c01046e9aaee95ab70..05cfae0691722f3c86023a59f3328606a1db08bd 100644 (file)
--- a/src/nameidmapping.cpp
+++ b/src/nameidmapping.cpp
@@ -27,7 +27,7 @@ void NameIdMapping::serialize(std::ostream &os) const
        writeU16(os, m_id_to_name.size());
        for (const auto &i : m_id_to_name) {
                writeU16(os, i.first);
-               os << serializeString(i.second);
+               os << serializeString16(i.second);
        }
 }
 
@@ -41,7 +41,7 @@ void NameIdMapping::deSerialize(std::istream &is)
        m_name_to_id.clear();
        for (u32 i = 0; i < count; i++) {
                u16 id = readU16(is);
-               std::string name = deSerializeString(is);
+               std::string name = deSerializeString16(is);
                m_id_to_name[id] = name;
                m_name_to_id[name] = id;
        }

diff --git a/src/network/clientpackethandler.cpp b/src/network/clientpackethandler.cpp
index 8d87ff8f215e7ebb98031df8fc7dc80b248d4e2b..5683564a0aff8a1f50985b953bcf8d1eeb36ab02 100644 (file)
--- a/src/network/clientpackethandler.cpp
+++ b/src/network/clientpackethandler.cpp
@@ -497,7 +497,7 @@ void Client::handleCommand_ActiveObjectMessages(NetworkPacket* pkt)
                        if (!is.good())
                                break;
 
-                       std::string message = deSerializeString(is);
+                       std::string message = deSerializeString16(is);
 
                        // Pass on to the environment
                        m_env.processActiveObjectMessage(id, message);
@@ -994,7 +994,7 @@ void Client::handleCommand_AddParticleSpawner(NetworkPacket* pkt)
        p.minsize            = readF32(is);
        p.maxsize            = readF32(is);
        p.collisiondetection = readU8(is);
-       p.texture            = deSerializeLongString(is);
+       p.texture            = deSerializeString32(is);
 
        server_id = readU32(is);
 
@@ -1207,11 +1207,11 @@ void Client::handleCommand_HudSetSky(NetworkPacket* pkt)
 
                SkyboxParams skybox;
                skybox.bgcolor = video::SColor(readARGB8(is));
-               skybox.type = std::string(deSerializeString(is));
+               skybox.type = std::string(deSerializeString16(is));
                u16 count = readU16(is);
 
                for (size_t i = 0; i < count; i++)
-                       skybox.textures.emplace_back(deSerializeString(is));
+                       skybox.textures.emplace_back(deSerializeString16(is));
 
                skybox.clouds = true;
                try {

diff --git a/src/nodedef.cpp b/src/nodedef.cpp
index 392f5eb9830ce7fda1a50b43c2538bb7568cba50..3a5934cf3ac448dce0b76dffffe3337202f74638 100644 (file)
--- a/src/nodedef.cpp
+++ b/src/nodedef.cpp
@@ -207,7 +207,7 @@ void TileDef::serialize(std::ostream &os, u16 protocol_version) const
        u8 version = 6;
        writeU8(os, version);
 
-       os << serializeString(name);
+       os << serializeString16(name);
        animation.serialize(os, version);
        bool has_scale = scale > 0;
        u16 flags = 0;
@@ -241,7 +241,7 @@ void TileDef::deSerialize(std::istream &is, u8 contentfeatures_version,
        int version = readU8(is);
        if (version < 6)
                throw SerializationError("unsupported TileDef version");
-       name = deSerializeString(is);
+       name = deSerializeString16(is);
        animation.deSerialize(is, version);
        u16 flags = readU16(is);
        backface_culling = flags & TILE_FLAG_BACKFACE_CULLING;
@@ -416,10 +416,10 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
        writeU8(os, version);
 
        // general
-       os << serializeString(name);
+       os << serializeString16(name);
        writeU16(os, groups.size());
        for (const auto &group : groups) {
-               os << serializeString(group.first);
+               os << serializeString16(group.first);
                writeS16(os, group.second);
        }
        writeU8(os, param_type);
@@ -427,7 +427,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
 
        // visual
        writeU8(os, drawtype);
-       os << serializeString(mesh);
+       os << serializeString16(mesh);
        writeF32(os, visual_scale);
        writeU8(os, 6);
        for (const TileDef &td : tiledef)
@@ -442,7 +442,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
        writeU8(os, color.getRed());
        writeU8(os, color.getGreen());
        writeU8(os, color.getBlue());
-       os << serializeString(palette_name);
+       os << serializeString16(palette_name);
        writeU8(os, waving);
        writeU8(os, connect_sides);
        writeU16(os, connects_to_ids.size());
@@ -470,8 +470,8 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
 
        // liquid
        writeU8(os, liquid_type);
-       os << serializeString(liquid_alternative_flowing);
-       os << serializeString(liquid_alternative_source);
+       os << serializeString16(liquid_alternative_flowing);
+       os << serializeString16(liquid_alternative_source);
        writeU8(os, liquid_viscosity);
        writeU8(os, liquid_renewable);
        writeU8(os, liquid_range);
@@ -492,7 +492,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
        writeU8(os, legacy_facedir_simple);
        writeU8(os, legacy_wallmounted);
 
-       os << serializeString(node_dig_prediction);
+       os << serializeString16(node_dig_prediction);
        writeU8(os, leveled_max);
 }
 
@@ -519,11 +519,11 @@ void ContentFeatures::deSerialize(std::istream &is)
                throw SerializationError("unsupported ContentFeatures version");
 
        // general
-       name = deSerializeString(is);
+       name = deSerializeString16(is);
        groups.clear();
        u32 groups_size = readU16(is);
        for (u32 i = 0; i < groups_size; i++) {
-               std::string name = deSerializeString(is);
+               std::string name = deSerializeString16(is);
                int value = readS16(is);
                groups[name] = value;
        }
@@ -532,7 +532,7 @@ void ContentFeatures::deSerialize(std::istream &is)
 
        // visual
        drawtype = (enum NodeDrawType) readU8(is);
-       mesh = deSerializeString(is);
+       mesh = deSerializeString16(is);
        visual_scale = readF32(is);
        if (readU8(is) != 6)
                throw SerializationError("unsupported tile count");
@@ -548,7 +548,7 @@ void ContentFeatures::deSerialize(std::istream &is)
        color.setRed(readU8(is));
        color.setGreen(readU8(is));
        color.setBlue(readU8(is));
-       palette_name = deSerializeString(is);
+       palette_name = deSerializeString16(is);
        waving = readU8(is);
        connect_sides = readU8(is);
        u16 connects_to_size = readU16(is);
@@ -578,8 +578,8 @@ void ContentFeatures::deSerialize(std::istream &is)
 
        // liquid
        liquid_type = (enum LiquidType) readU8(is);
-       liquid_alternative_flowing = deSerializeString(is);
-       liquid_alternative_source = deSerializeString(is);
+       liquid_alternative_flowing = deSerializeString16(is);
+       liquid_alternative_source = deSerializeString16(is);
        liquid_viscosity = readU8(is);
        liquid_renewable = readU8(is);
        liquid_range = readU8(is);
@@ -601,7 +601,7 @@ void ContentFeatures::deSerialize(std::istream &is)
        legacy_wallmounted = readU8(is);
 
        try {
-               node_dig_prediction = deSerializeString(is);
+               node_dig_prediction = deSerializeString16(is);
                u8 tmp_leveled_max = readU8(is);
                if (is.eof()) /* readU8 doesn't throw exceptions so we have to do this */
                        throw SerializationError("");
@@ -1472,7 +1472,7 @@ void NodeDefManager::serialize(std::ostream &os, u16 protocol_version) const
                // strict version incompatibilities
                std::ostringstream wrapper_os(std::ios::binary);
                f->serialize(wrapper_os, protocol_version);
-               os2<<serializeString(wrapper_os.str());
+               os2<<serializeString16(wrapper_os.str());
 
                // must not overflow
                u16 next = count + 1;
@@ -1480,7 +1480,7 @@ void NodeDefManager::serialize(std::ostream &os, u16 protocol_version) const
                count++;
        }
        writeU16(os, count);
-       os << serializeLongString(os2.str());
+       os << serializeString32(os2.str());
 }
 
 
@@ -1491,13 +1491,13 @@ void NodeDefManager::deSerialize(std::istream &is)
        if (version != 1)
                throw SerializationError("unsupported NodeDefinitionManager version");
        u16 count = readU16(is);
-       std::istringstream is2(deSerializeLongString(is), std::ios::binary);
+       std::istringstream is2(deSerializeString32(is), std::ios::binary);
        ContentFeatures f;
        for (u16 n = 0; n < count; n++) {
                u16 i = readU16(is2);
 
                // Read it from the string wrapper
-               std::string wrapper = deSerializeString(is2);
+               std::string wrapper = deSerializeString16(is2);
                std::istringstream wrapper_is(wrapper, std::ios::binary);
                f.deSerialize(wrapper_is);
 

diff --git a/src/nodemetadata.cpp b/src/nodemetadata.cpp
index b84ffc8cbc2f9230534259fd7cc5670603303097..6447c8785b9919fec4fb6028aacd595fc951b47b 100644 (file)
--- a/src/nodemetadata.cpp
+++ b/src/nodemetadata.cpp
@@ -49,8 +49,8 @@ void NodeMetadata::serialize(std::ostream &os, u8 version, bool disk) const
                if (!disk && priv)
                        continue;
 
-               os << serializeString(sv.first);
-               os << serializeLongString(sv.second);
+               os << serializeString16(sv.first);
+               os << serializeString32(sv.second);
                if (version >= 2)
                        writeU8(os, (priv) ? 1 : 0);
        }
@@ -63,8 +63,8 @@ void NodeMetadata::deSerialize(std::istream &is, u8 version)
        clear();
        int num_vars = readU32(is);
        for(int i=0; i<num_vars; i++){
-               std::string name = deSerializeString(is);
-               std::string var = deSerializeLongString(is);
+               std::string name = deSerializeString16(is);
+               std::string var = deSerializeString32(is);
                m_stringvars[name] = var;
                if (version >= 2) {
                        if (readU8(is) == 1)

diff --git a/src/object_properties.cpp b/src/object_properties.cpp
index 8d51bcbfa1cdf1f4212727475d8c529b16c0526d..c31c667e7a6b7e76fc4dc9c6dea64634bd7e4400 100644 (file)
--- a/src/object_properties.cpp
+++ b/src/object_properties.cpp
@@ -84,11 +84,11 @@ void ObjectProperties::serialize(std::ostream &os) const
        writeV3F32(os, selectionbox.MinEdge);
        writeV3F32(os, selectionbox.MaxEdge);
        writeU8(os, pointable);
-       os << serializeString(visual);
+       os << serializeString16(visual);
        writeV3F32(os, visual_size);
        writeU16(os, textures.size());
        for (const std::string &texture : textures) {
-               os << serializeString(texture);
+               os << serializeString16(texture);
        }
        writeV2S16(os, spritediv);
        writeV2S16(os, initial_sprite_basepos);
@@ -96,7 +96,7 @@ void ObjectProperties::serialize(std::ostream &os) const
        writeU8(os, makes_footstep_sound);
        writeF32(os, automatic_rotate);
        // Added in protocol version 14
-       os << serializeString(mesh);
+       os << serializeString16(mesh);
        writeU16(os, colors.size());
        for (video::SColor color : colors) {
                writeARGB8(os, color);
@@ -106,17 +106,17 @@ void ObjectProperties::serialize(std::ostream &os) const
        writeU8(os, automatic_face_movement_dir);
        writeF32(os, automatic_face_movement_dir_offset);
        writeU8(os, backface_culling);
-       os << serializeString(nametag);
+       os << serializeString16(nametag);
        writeARGB8(os, nametag_color);
        writeF32(os, automatic_face_movement_max_rotation_per_sec);
-       os << serializeString(infotext);
-       os << serializeString(wield_item);
+       os << serializeString16(infotext);
+       os << serializeString16(wield_item);
        writeS8(os, glow);
        writeU16(os, breath_max);
        writeF32(os, eye_height);
        writeF32(os, zoom_fov);
        writeU8(os, use_texture_alpha);
-       os << serializeString(damage_texture_modifier);
+       os << serializeString16(damage_texture_modifier);
        writeU8(os, shaded);
 
        // Add stuff only at the bottom.
@@ -137,19 +137,19 @@ void ObjectProperties::deSerialize(std::istream &is)
        selectionbox.MinEdge = readV3F32(is);
        selectionbox.MaxEdge = readV3F32(is);
        pointable = readU8(is);
-       visual = deSerializeString(is);
+       visual = deSerializeString16(is);
        visual_size = readV3F32(is);
        textures.clear();
        u32 texture_count = readU16(is);
        for (u32 i = 0; i < texture_count; i++){
-               textures.push_back(deSerializeString(is));
+               textures.push_back(deSerializeString16(is));
        }
        spritediv = readV2S16(is);
        initial_sprite_basepos = readV2S16(is);
        is_visible = readU8(is);
        makes_footstep_sound = readU8(is);
        automatic_rotate = readF32(is);
-       mesh = deSerializeString(is);
+       mesh = deSerializeString16(is);
        colors.clear();
        u32 color_count = readU16(is);
        for (u32 i = 0; i < color_count; i++){
@@ -160,18 +160,18 @@ void ObjectProperties::deSerialize(std::istream &is)
        automatic_face_movement_dir = readU8(is);
        automatic_face_movement_dir_offset = readF32(is);
        backface_culling = readU8(is);
-       nametag = deSerializeString(is);
+       nametag = deSerializeString16(is);
        nametag_color = readARGB8(is);
        automatic_face_movement_max_rotation_per_sec = readF32(is);
-       infotext = deSerializeString(is);
-       wield_item = deSerializeString(is);
+       infotext = deSerializeString16(is);
+       wield_item = deSerializeString16(is);
        glow = readS8(is);
        breath_max = readU16(is);
        eye_height = readF32(is);
        zoom_fov = readF32(is);
        use_texture_alpha = readU8(is);
        try {
-               damage_texture_modifier = deSerializeString(is);
+               damage_texture_modifier = deSerializeString16(is);
                u8 tmp = readU8(is);
                if (is.eof())
                        throw SerializationError("");

diff --git a/src/particles.cpp b/src/particles.cpp
index fd81238dc5e0f5bb41d0f1d852a39e00045a0b9c..14c987958bdb84639170170f49001d1c1aa68d73 100644 (file)
--- a/src/particles.cpp
+++ b/src/particles.cpp
@@ -28,7 +28,7 @@ void ParticleParameters::serialize(std::ostream &os, u16 protocol_ver) const
        writeF32(os, expirationtime);
        writeF32(os, size);
        writeU8(os, collisiondetection);
-       os << serializeLongString(texture);
+       os << serializeString32(texture);
        writeU8(os, vertical);
        writeU8(os, collision_removal);
        animation.serialize(os, 6); /* NOT the protocol ver */
@@ -47,7 +47,7 @@ void ParticleParameters::deSerialize(std::istream &is, u16 protocol_ver)
        expirationtime     = readF32(is);
        size               = readF32(is);
        collisiondetection = readU8(is);
-       texture            = deSerializeLongString(is);
+       texture            = deSerializeString32(is);
        vertical           = readU8(is);
        collision_removal  = readU8(is);
        animation.deSerialize(is, 6); /* NOT the protocol ver */

diff --git a/src/server.cpp b/src/server.cpp
index d40ff259f6968b2b9d23a72e560adbbb26bca499..982f904f4c491a515cf25678001b4b20714e6c07 100644 (file)
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -802,7 +802,7 @@ void Server::AsyncRunStep(bool initial_step)
                                        // u16 id
                                        // std::string data
                                        buffer.append(idbuf, sizeof(idbuf));
-                                       buffer.append(serializeString(aom.datastring));
+                                       buffer.append(serializeString16(aom.datastring));
                                }
                        }
                        /*
@@ -1993,7 +1993,7 @@ void Server::SendActiveObjectRemoveAdd(RemoteClient *client, PlayerSAO *playersa
                writeU8((u8*)buf, type);
                data.append(buf, 1);
 
-               data.append(serializeLongString(
+               data.append(serializeString32(
                        obj->getClientInitializationData(client->net_proto_version)));
 
                // Add to known objects

diff --git a/src/server/luaentity_sao.cpp b/src/server/luaentity_sao.cpp
index d504c42caab762187cbe064f0c5a9b7be8b7f6b9..f20914f7f3f1196c6543e31ab35bc4e5111477fe 100644 (file)
--- a/src/server/luaentity_sao.cpp
+++ b/src/server/luaentity_sao.cpp
@@ -42,8 +42,8 @@ LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos, const std::string &d
                u8 version2 = 0;
                u8 version = readU8(is);
 
-               name = deSerializeString(is);
-               state = deSerializeLongString(is);
+               name = deSerializeString16(is);
+               state = deSerializeString32(is);
 
                if (version < 1)
                        break;
@@ -225,7 +225,7 @@ std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
 
        // PROTOCOL_VERSION >= 37
        writeU8(os, 1); // version
-       os << serializeString(""); // name
+       os << serializeString16(""); // name
        writeU8(os, 0); // is_player
        writeU16(os, getId()); //id
        writeV3F32(os, m_base_position);
@@ -233,26 +233,26 @@ std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
        writeU16(os, m_hp);
 
        std::ostringstream msg_os(std::ios::binary);
-       msg_os << serializeLongString(getPropertyPacket()); // message 1
-       msg_os << serializeLongString(generateUpdateArmorGroupsCommand()); // 2
-       msg_os << serializeLongString(generateUpdateAnimationCommand()); // 3
+       msg_os << serializeString32(getPropertyPacket()); // message 1
+       msg_os << serializeString32(generateUpdateArmorGroupsCommand()); // 2
+       msg_os << serializeString32(generateUpdateAnimationCommand()); // 3
        for (const auto &bone_pos : m_bone_position) {
-               msg_os << serializeLongString(generateUpdateBonePositionCommand(
+               msg_os << serializeString32(generateUpdateBonePositionCommand(
                        bone_pos.first, bone_pos.second.X, bone_pos.second.Y)); // m_bone_position.size
        }
-       msg_os << serializeLongString(generateUpdateAttachmentCommand()); // 4
+       msg_os << serializeString32(generateUpdateAttachmentCommand()); // 4
 
        int message_count = 4 + m_bone_position.size();
 
        for (const auto &id : getAttachmentChildIds()) {
                if (ServerActiveObject *obj = m_env->getActiveObject(id)) {
                        message_count++;
-                       msg_os << serializeLongString(obj->generateUpdateInfantCommand(
+                       msg_os << serializeString32(obj->generateUpdateInfantCommand(
                                id, protocol_version));
                }
        }
 
-       msg_os << serializeLongString(generateSetTextureModCommand());
+       msg_os << serializeString32(generateSetTextureModCommand());
        message_count++;
 
        writeU8(os, message_count);
@@ -270,14 +270,14 @@ void LuaEntitySAO::getStaticData(std::string *result) const
        // version must be 1 to keep backwards-compatibility. See version2
        writeU8(os, 1);
        // name
-       os<<serializeString(m_init_name);
+       os<<serializeString16(m_init_name);
        // state
        if(m_registered){
                std::string state = m_env->getScriptIface()->
                        luaentity_GetStaticdata(m_id);
-               os<<serializeLongString(state);
+               os<<serializeString32(state);
        } else {
-               os<<serializeLongString(m_init_state);
+               os<<serializeString32(m_init_state);
        }
        writeU16(os, m_hp);
        writeV3F1000(os, m_velocity);
@@ -436,7 +436,7 @@ std::string LuaEntitySAO::generateSetTextureModCommand() const
        // command
        writeU8(os, AO_CMD_SET_TEXTURE_MOD);
        // parameters
-       os << serializeString(m_current_texture_modifier);
+       os << serializeString16(m_current_texture_modifier);
        return os.str();
 }
 

diff --git a/src/server/player_sao.cpp b/src/server/player_sao.cpp
index e5b239bbaac0ec75915426ae2ffc037cb5062105..8d4938c3cdb920add5bd2cae81a70d0f7468cf3d 100644 (file)
--- a/src/server/player_sao.cpp
+++ b/src/server/player_sao.cpp
@@ -109,7 +109,7 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
 
        // Protocol >= 15
        writeU8(os, 1); // version
-       os << serializeString(m_player->getName()); // name
+       os << serializeString16(m_player->getName()); // name
        writeU8(os, 1); // is_player
        writeS16(os, getId()); // id
        writeV3F32(os, m_base_position);
@@ -117,22 +117,22 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
        writeU16(os, getHP());
 
        std::ostringstream msg_os(std::ios::binary);
-       msg_os << serializeLongString(getPropertyPacket()); // message 1
-       msg_os << serializeLongString(generateUpdateArmorGroupsCommand()); // 2
-       msg_os << serializeLongString(generateUpdateAnimationCommand()); // 3
+       msg_os << serializeString32(getPropertyPacket()); // message 1
+       msg_os << serializeString32(generateUpdateArmorGroupsCommand()); // 2
+       msg_os << serializeString32(generateUpdateAnimationCommand()); // 3
        for (const auto &bone_pos : m_bone_position) {
-               msg_os << serializeLongString(generateUpdateBonePositionCommand(
+               msg_os << serializeString32(generateUpdateBonePositionCommand(
                        bone_pos.first, bone_pos.second.X, bone_pos.second.Y)); // m_bone_position.size
        }
-       msg_os << serializeLongString(generateUpdateAttachmentCommand()); // 4
-       msg_os << serializeLongString(generateUpdatePhysicsOverrideCommand()); // 5
+       msg_os << serializeString32(generateUpdateAttachmentCommand()); // 4
+       msg_os << serializeString32(generateUpdatePhysicsOverrideCommand()); // 5
 
        int message_count = 5 + m_bone_position.size();
 
        for (const auto &id : getAttachmentChildIds()) {
                if (ServerActiveObject *obj = m_env->getActiveObject(id)) {
                        message_count++;
-                       msg_os << serializeLongString(obj->generateUpdateInfantCommand(
+                       msg_os << serializeString32(obj->generateUpdateInfantCommand(
                                id, protocol_version));
                }
        }

diff --git a/src/server/serveractiveobject.cpp b/src/server/serveractiveobject.cpp
index 3341dc008ad259b8865812c5966883a3f80a5fc8..8cb59b2d633305f8cb0fd4ab5412777c4b62b324 100644 (file)
--- a/src/server/serveractiveobject.cpp
+++ b/src/server/serveractiveobject.cpp
@@ -61,7 +61,7 @@ std::string ServerActiveObject::generateUpdateInfantCommand(u16 infant_id, u16 p
                // Clients since 4aa9a66 so no longer need this data
                // Version 38 is the first bump after that commit.
                // See also: ClientEnvironment::addActiveObject
-               os << serializeLongString(getClientInitializationData(protocol_version));
+               os << serializeString32(getClientInitializationData(protocol_version));
        }
        return os.str();
 }

diff --git a/src/server/unit_sao.cpp b/src/server/unit_sao.cpp
index ef0e87f2cec1ecd0e49534f18fe4f6214fcc5385..d906e885e16f113a3ef9509dd1656bbad3aefd69 100644 (file)
--- a/src/server/unit_sao.cpp
+++ b/src/server/unit_sao.cpp
@@ -242,7 +242,7 @@ std::string UnitSAO::generateUpdateAttachmentCommand() const
        writeU8(os, AO_CMD_ATTACH_TO);
        // parameters
        writeS16(os, m_attachment_parent_id);
-       os << serializeString(m_attachment_bone);
+       os << serializeString16(m_attachment_bone);
        writeV3F32(os, m_attachment_position);
        writeV3F32(os, m_attachment_rotation);
        return os.str();
@@ -255,7 +255,7 @@ std::string UnitSAO::generateUpdateBonePositionCommand(
        // command
        writeU8(os, AO_CMD_SET_BONE_POSITION);
        // parameters
-       os << serializeString(bone);
+       os << serializeString16(bone);
        writeV3F32(os, position);
        writeV3F32(os, rotation);
        return os.str();
@@ -291,7 +291,7 @@ std::string UnitSAO::generateUpdateArmorGroupsCommand() const
        writeU8(os, AO_CMD_UPDATE_ARMOR_GROUPS);
        writeU16(os, m_armor_groups.size());
        for (const auto &armor_group : m_armor_groups) {
-               os << serializeString(armor_group.first);
+               os << serializeString16(armor_group.first);
                writeS16(os, armor_group.second);
        }
        return os.str();

diff --git a/src/sound.h b/src/sound.h
index 6cbd55e8fdb8d9337cd1976d783e1bdb575ac95f..6f7b0a1af23616983f745e66b156fc1baed01586 100644 (file)
--- a/src/sound.h
+++ b/src/sound.h
@@ -39,7 +39,7 @@ struct SimpleSoundSpec
        // keep in sync with item definitions
        void serialize(std::ostream &os, u8 cf_version) const
        {
-               os << serializeString(name);
+               os << serializeString16(name);
                writeF32(os, gain);
                writeF32(os, pitch);
                writeF32(os, fade);
@@ -49,7 +49,7 @@ struct SimpleSoundSpec
 
        void deSerialize(std::istream &is, u8 cf_version)
        {
-               name = deSerializeString(is);
+               name = deSerializeString16(is);
                gain = readF32(is);
                pitch = readF32(is);
                fade = readF32(is);

diff --git a/src/staticobject.cpp b/src/staticobject.cpp
index 5ccb7baf5227893eeb366693eca6c226349dda76..86e455b9f65093247d5aaf09609733657e6d1db0 100644 (file)
--- a/src/staticobject.cpp
+++ b/src/staticobject.cpp
@@ -35,7 +35,7 @@ void StaticObject::serialize(std::ostream &os)
        // pos
        writeV3F1000(os, pos);
        // data
-       os<<serializeString(data);
+       os<<serializeString16(data);
 }
 void StaticObject::deSerialize(std::istream &is, u8 version)
 {
@@ -44,7 +44,7 @@ void StaticObject::deSerialize(std::istream &is, u8 version)
        // pos
        pos = readV3F1000(is);
        // data
-       data = deSerializeString(is);
+       data = deSerializeString16(is);
 }
 
 void StaticObjectList::serialize(std::ostream &os)

diff --git a/src/tool.cpp b/src/tool.cpp
index 22e41d28e1d67a9bb2f1af83dc5724309df3846f..90f4f9c128cee94bbad29798b05bd71828a1fdb6 100644 (file)
--- a/src/tool.cpp
+++ b/src/tool.cpp
@@ -66,7 +66,7 @@ void ToolCapabilities::serialize(std::ostream &os, u16 protocol_version) const
        for (const auto &groupcap : groupcaps) {
                const std::string *name = &groupcap.first;
                const ToolGroupCap *cap = &groupcap.second;
-               os << serializeString(*name);
+               os << serializeString16(*name);
                writeS16(os, cap->uses);
                writeS16(os, cap->maxlevel);
                writeU32(os, cap->times.size());
@@ -79,7 +79,7 @@ void ToolCapabilities::serialize(std::ostream &os, u16 protocol_version) const
        writeU32(os, damageGroups.size());
 
        for (const auto &damageGroup : damageGroups) {
-               os << serializeString(damageGroup.first);
+               os << serializeString16(damageGroup.first);
                writeS16(os, damageGroup.second);
        }
 
@@ -98,7 +98,7 @@ void ToolCapabilities::deSerialize(std::istream &is)
        groupcaps.clear();
        u32 groupcaps_size = readU32(is);
        for (u32 i = 0; i < groupcaps_size; i++) {
-               std::string name = deSerializeString(is);
+               std::string name = deSerializeString16(is);
                ToolGroupCap cap;
                cap.uses = readS16(is);
                cap.maxlevel = readS16(is);
@@ -113,7 +113,7 @@ void ToolCapabilities::deSerialize(std::istream &is)
 
        u32 damage_groups_size = readU32(is);
        for (u32 i = 0; i < damage_groups_size; i++) {
-               std::string name = deSerializeString(is);
+               std::string name = deSerializeString16(is);
                s16 rating = readS16(is);
                damageGroups[name] = rating;
        }

diff --git a/src/unittest/test_serialization.cpp b/src/unittest/test_serialization.cpp
index d72bf0d4ca38e307462477ab2449bcddcd279d10..660d77d02fe9eecf2d8e8597550bd9cec519cb08 100644 (file)
--- a/src/unittest/test_serialization.cpp
+++ b/src/unittest/test_serialization.cpp
@@ -44,7 +44,7 @@ class TestSerialization : public TestBase {
        std::wstring teststring2_w;
        std::string teststring2_w_encoded;
 
-       static const u8 test_serialized_data[12 * 13 - 8];
+       static const u8 test_serialized_data[12 * 11 - 2];
 };
 
 static TestSerialization g_test_instance;
@@ -91,21 +91,21 @@ void TestSerialization::buildTestStrings()
 void TestSerialization::testSerializeString()
 {
        // Test blank string
-       UASSERT(serializeString("") == mkstr("\0\0"));
+       UASSERT(serializeString16("") == mkstr("\0\0"));
 
        // Test basic string
-       UASSERT(serializeString("Hello world!") == mkstr("\0\14Hello world!"));
+       UASSERT(serializeString16("Hello world!") == mkstr("\0\14Hello world!"));
 
        // Test character range
-       UASSERT(serializeString(teststring2) == mkstr("\1\0") + teststring2);
+       UASSERT(serializeString16(teststring2) == mkstr("\1\0") + teststring2);
 }
 
 void TestSerialization::testDeSerializeString()
 {
        // Test deserialize
        {
-               std::istringstream is(serializeString(teststring2), std::ios::binary);
-               UASSERT(deSerializeString(is) == teststring2);
+               std::istringstream is(serializeString16(teststring2), std::ios::binary);
+               UASSERT(deSerializeString16(is) == teststring2);
                UASSERT(!is.eof());
                is.get();
                UASSERT(is.eof());
@@ -114,34 +114,34 @@ void TestSerialization::testDeSerializeString()
        // Test deserialize an incomplete length specifier
        {
                std::istringstream is(mkstr("\x53"), std::ios::binary);
-               EXCEPTION_CHECK(SerializationError, deSerializeString(is));
+               EXCEPTION_CHECK(SerializationError, deSerializeString16(is));
        }
 
        // Test deserialize a string with incomplete data
        {
                std::istringstream is(mkstr("\x00\x55 abcdefg"), std::ios::binary);
-               EXCEPTION_CHECK(SerializationError, deSerializeString(is));
+               EXCEPTION_CHECK(SerializationError, deSerializeString16(is));
        }
 }
 
 void TestSerialization::testSerializeLongString()
 {
        // Test blank string
-       UASSERT(serializeLongString("") == mkstr("\0\0\0\0"));
+       UASSERT(serializeString32("") == mkstr("\0\0\0\0"));
 
        // Test basic string
-       UASSERT(serializeLongString("Hello world!") == mkstr("\0\0\0\14Hello world!"));
+       UASSERT(serializeString32("Hello world!") == mkstr("\0\0\0\14Hello world!"));
 
        // Test character range
-       UASSERT(serializeLongString(teststring2) == mkstr("\0\0\1\0") + teststring2);
+       UASSERT(serializeString32(teststring2) == mkstr("\0\0\1\0") + teststring2);
 }
 
 void TestSerialization::testDeSerializeLongString()
 {
        // Test deserialize
        {
-               std::istringstream is(serializeLongString(teststring2), std::ios::binary);
-               UASSERT(deSerializeLongString(is) == teststring2);
+               std::istringstream is(serializeString32(teststring2), std::ios::binary);
+               UASSERT(deSerializeString32(is) == teststring2);
                UASSERT(!is.eof());
                is.get();
                UASSERT(is.eof());
@@ -150,19 +150,19 @@ void TestSerialization::testDeSerializeLongString()
        // Test deserialize an incomplete length specifier
        {
                std::istringstream is(mkstr("\x53"), std::ios::binary);
-               EXCEPTION_CHECK(SerializationError, deSerializeLongString(is));
+               EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
        }
 
        // Test deserialize a string with incomplete data
        {
                std::istringstream is(mkstr("\x00\x00\x00\x05 abc"), std::ios::binary);
-               EXCEPTION_CHECK(SerializationError, deSerializeLongString(is));
+               EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
        }
 
        // Test deserialize a string with a length too large
        {
                std::istringstream is(mkstr("\xFF\xFF\xFF\xFF blah"), std::ios::binary);
-               EXCEPTION_CHECK(SerializationError, deSerializeLongString(is));
+               EXCEPTION_CHECK(SerializationError, deSerializeString32(is));
        }
 }
 
@@ -235,19 +235,17 @@ void TestSerialization::testStreamRead()
        UASSERT(readF1000(is) == F1000_MIN);
        UASSERT(readF1000(is) == F1000_MAX);
 
-       UASSERT(deSerializeString(is) == "foobar!");
+       UASSERT(deSerializeString16(is) == "foobar!");
 
        UASSERT(readV2S16(is) == v2s16(500, 500));
        UASSERT(readV3S16(is) == v3s16(4207, 604, -30));
        UASSERT(readV2S32(is) == v2s32(1920, 1080));
        UASSERT(readV3S32(is) == v3s32(-400, 6400054, 290549855));
 
-       UASSERT(deSerializeWideString(is) == L"\x02~woof~\x5455");
-
        UASSERT(readV3F1000(is) == v3f(500, 10024.2f, -192.54f));
        UASSERT(readARGB8(is) == video::SColor(255, 128, 50, 128));
 
-       UASSERT(deSerializeLongString(is) == "some longer string here");
+       UASSERT(deSerializeString32(is) == "some longer string here");
 
        UASSERT(is.rdbuf()->in_avail() == 2);
        UASSERT(readU16(is) == 0xF00D);
@@ -275,7 +273,7 @@ void TestSerialization::testStreamWrite()
        writeF1000(os, F1000_MIN);
        writeF1000(os, F1000_MAX);
 
-       os << serializeString("foobar!");
+       os << serializeString16("foobar!");
 
        data = os.str();
        UASSERT(data.size() < sizeof(test_serialized_data));
@@ -286,12 +284,10 @@ void TestSerialization::testStreamWrite()
        writeV2S32(os, v2s32(1920, 1080));
        writeV3S32(os, v3s32(-400, 6400054, 290549855));
 
-       os << serializeWideString(L"\x02~woof~\x5455");
-
        writeV3F1000(os, v3f(500, 10024.2f, -192.54f));
        writeARGB8(os, video::SColor(255, 128, 50, 128));
 
-       os << serializeLongString("some longer string here");
+       os << serializeString32("some longer string here");
 
        writeU16(os, 0xF00D);
 
@@ -384,7 +380,7 @@ void TestSerialization::testFloatFormat()
                UASSERT(test_single(i));
 }
 
-const u8 TestSerialization::test_serialized_data[12 * 13 - 8] = {
+const u8 TestSerialization::test_serialized_data[12 * 11 - 2] = {
        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
        0xdd, 0xee, 0xff, 0x80, 0x75, 0x30, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0xd1, 0x1e, 0xee, 0x1e,
@@ -392,9 +388,7 @@ const u8 TestSerialization::test_serialized_data[12 * 13 - 8] = {
        0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, 0x21, 0x01, 0xf4, 0x01, 0xf4, 0x10,
        0x6f, 0x02, 0x5c, 0xff, 0xe2, 0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0x04,
        0x38, 0xff, 0xff, 0xfe, 0x70, 0x00, 0x61, 0xa8, 0x36, 0x11, 0x51, 0x70,
-       0x5f, 0x00, 0x08, 0x00,
-       0x02, 0x00, 0x7e, 0x00,  'w', 0x00,  'o', 0x00,  'o', 0x00,  'f', 0x00, // \x02~woof~\x5455
-       0x7e, 0x54, 0x55, 0x00, 0x07, 0xa1, 0x20, 0x00, 0x98, 0xf5, 0x08, 0xff,
+       0x5f, 0x00, 0x07, 0xa1, 0x20, 0x00, 0x98, 0xf5, 0x08, 0xff,
        0xfd, 0x0f, 0xe4, 0xff, 0x80, 0x32, 0x80, 0x00, 0x00, 0x00, 0x17, 0x73,
        0x6f, 0x6d, 0x65, 0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x73,
        0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x68, 0x65, 0x72, 0x65, 0xF0, 0x0D,

diff --git a/src/util/serialize.cpp b/src/util/serialize.cpp
index fd5cbda218eb025592cf4e20f403448dd25d28ac..d770101f20b19c585fc1ea98a5ad77dceb24fbea 100644 (file)
--- a/src/util/serialize.cpp
+++ b/src/util/serialize.cpp
@@ -35,13 +35,13 @@ FloatType g_serialize_f32_type = FLOATTYPE_UNKNOWN;
 //// String
 ////
 
-std::string serializeString(const std::string &plain)
+std::string serializeString16(const std::string &plain)
 {
        std::string s;
        char buf[2];
 
        if (plain.size() > STRING_MAX_LEN)
-               throw SerializationError("String too long for serializeString");
+               throw SerializationError("String too long for serializeString16");
        s.reserve(2 + plain.size());
 
        writeU16((u8 *)&buf[0], plain.size());
@@ -51,14 +51,14 @@ std::string serializeString(const std::string &plain)
        return s;
 }
 
-std::string deSerializeString(std::istream &is)
+std::string deSerializeString16(std::istream &is)
 {
        std::string s;
        char buf[2];
 
        is.read(buf, 2);
        if (is.gcount() != 2)
-               throw SerializationError("deSerializeString: size not read");
+               throw SerializationError("deSerializeString16: size not read");
 
        u16 s_size = readU16((u8 *)buf);
        if (s_size == 0)
@@ -67,66 +67,17 @@ std::string deSerializeString(std::istream &is)
        s.resize(s_size);
        is.read(&s[0], s_size);
        if (is.gcount() != s_size)
-               throw SerializationError("deSerializeString: couldn't read all chars");
+               throw SerializationError("deSerializeString16: couldn't read all chars");
 
        return s;
 }
 
-////
-//// Wide String
-////
-
-std::string serializeWideString(const std::wstring &plain)
-{
-       std::string s;
-       char buf[2];
-
-       if (plain.size() > WIDE_STRING_MAX_LEN)
-               throw SerializationError("String too long for serializeWideString");
-       s.reserve(2 + 2 * plain.size());
-
-       writeU16((u8 *)buf, plain.size());
-       s.append(buf, 2);
-
-       for (wchar_t i : plain) {
-               writeU16((u8 *)buf, i);
-               s.append(buf, 2);
-       }
-       return s;
-}
-
-std::wstring deSerializeWideString(std::istream &is)
-{
-       std::wstring s;
-       char buf[2];
-
-       is.read(buf, 2);
-       if (is.gcount() != 2)
-               throw SerializationError("deSerializeWideString: size not read");
-
-       u16 s_size = readU16((u8 *)buf);
-       if (s_size == 0)
-               return s;
-
-       s.reserve(s_size);
-       for (u32 i = 0; i < s_size; i++) {
-               is.read(&buf[0], 2);
-               if (is.gcount() != 2) {
-                       throw SerializationError(
-                               "deSerializeWideString: couldn't read all chars");
-               }
-
-               wchar_t c16 = readU16((u8 *)buf);
-               s.append(&c16, 1);
-       }
-       return s;
-}
 
 ////
 //// Long String
 ////
 
-std::string serializeLongString(const std::string &plain)
+std::string serializeString32(const std::string &plain)
 {
        std::string s;
        char buf[4];
@@ -141,7 +92,7 @@ std::string serializeLongString(const std::string &plain)
        return s;
 }
 
-std::string deSerializeLongString(std::istream &is)
+std::string deSerializeString32(std::istream &is)
 {
        std::string s;
        char buf[4];

diff --git a/src/util/serialize.h b/src/util/serialize.h
index a988a8f78f1eda557d76c2fa7f32826cf364fa49..b3ec28eab58ccf10e826db8cd37e38b44a4b55ab 100644 (file)
--- a/src/util/serialize.h
+++ b/src/util/serialize.h
@@ -440,16 +440,16 @@ MAKE_STREAM_WRITE_FXN(video::SColor, ARGB8, 4);
 ////
 
 // Creates a string with the length as the first two bytes
-std::string serializeString(const std::string &plain);
+std::string serializeString16(const std::string &plain);
 
 // Reads a string with the length as the first two bytes
-std::string deSerializeString(std::istream &is);
+std::string deSerializeString16(std::istream &is);
 
 // Creates a string with the length as the first four bytes
-std::string serializeLongString(const std::string &plain);
+std::string serializeString32(const std::string &plain);
 
 // Reads a string with the length as the first four bytes
-std::string deSerializeLongString(std::istream &is);
+std::string deSerializeString32(std::istream &is);
 
 // Creates a string encoded in JSON format (almost equivalent to a C string literal)
 std::string serializeJsonString(const std::string &plain);