void StaticObjectList::deSerialize(std::istream &is) { // version u8 version = readU8(is); // count u16 count = readU16(is); for(u16 i=0; i<count; i++) { StaticObject s_obj; s_obj.deSerialize(is, version); m_stored.push_back(s_obj); } }
void TileDef::deSerialize(std::istream &is, const u8 contenfeatures_version, const NodeDrawType drawtype) { int version = readU8(is); name = deSerializeString(is); animation.type = (TileAnimationType)readU8(is); animation.aspect_w = readU16(is); animation.aspect_h = readU16(is); animation.length = readF1000(is); if (version >= 1) backface_culling = readU8(is); if (version >= 2) { tileable_horizontal = readU8(is); tileable_vertical = readU8(is); } if ((contenfeatures_version < 8) && ((drawtype == NDT_MESH) || (drawtype == NDT_FIRELIKE) || (drawtype == NDT_LIQUID) || (drawtype == NDT_PLANTLIKE))) backface_culling = false; }
void ItemDefinition::deSerialize(std::istream &is) { // Reset everything reset(); // Deserialize int version = readU8(is); if(version != 1) throw SerializationError("unsupported ItemDefinition version"); type = (enum ItemType)readU8(is); name = deSerializeString(is); description = deSerializeString(is); inventory_image = deSerializeString(is); wield_image = deSerializeString(is); wield_scale = readV3F1000(is); stack_max = readS16(is); usable = readU8(is); liquids_pointable = readU8(is); std::string tool_capabilities_s = deSerializeString(is); if(!tool_capabilities_s.empty()) { std::istringstream tmp_is(tool_capabilities_s, std::ios::binary); tool_capabilities = new ToolCapabilities; tool_capabilities->deSerialize(tmp_is); } groups.clear(); u32 groups_size = readU16(is); for(u32 i=0; i<groups_size; i++){ std::string name = deSerializeString(is); int value = readS16(is); groups[name] = value; } // If you add anything here, insert it primarily inside the try-catch // block to not need to increase the version. try{ node_placement_prediction = deSerializeString(is); }catch(SerializationError &e) {}; }
status SampleVisionFile::parseLoops() { for (int i=0; i<8; i++) { uint32_t startFrame, endFrame; uint8_t type; uint16_t count; readU32(&startFrame); readU32(&endFrame); readU8(&type); readU16(&count); } return AF_SUCCEED; }
librevenge::RVNGString libvisio::VSDMetaData::readCodePageString(librevenge::RVNGInputStream *input) { uint32_t size = readU32(input); std::vector<unsigned char> characters; for (uint32_t i = 0; i < size; ++i) characters.push_back(readU8(input)); uint32_t codepage = getCodePage(); librevenge::RVNGString string; if (codepage == 65001) { // http://msdn.microsoft.com/en-us/library/windows/desktop/dd374130%28v=vs.85%29.aspx // says this is UTF-8. for (std::vector<unsigned char>::const_iterator i = characters.begin(); i != characters.end(); ++i) string.append((const char)*i); } else { UErrorCode status = U_ZERO_ERROR; UConverter *conv = 0; switch (codepage) { case 1252: // http://msdn.microsoft.com/en-us/goglobal/bb964654 conv = ucnv_open("windows-1252", &status); break; } if (U_SUCCESS(status) && conv) { const char *src = (const char *)&characters[0]; const char *srcLimit = (const char *)src + characters.size(); while (src < srcLimit) { UChar32 ucs4Character = ucnv_getNextUChar(conv, &src, srcLimit, &status); if (U_SUCCESS(status) && U_IS_UNICODE_CHAR(ucs4Character)) appendUCS4(string, ucs4Character); } } if (conv) ucnv_close(conv); } return string; }
static NodeMetadata* create(std::istream &is, IGameDef *gamedef) { GenericNodeMetadata *d = new GenericNodeMetadata(gamedef); d->m_inventory = new Inventory(gamedef->idef()); d->m_inventory->deSerialize(is); d->m_text = deSerializeLongString(is); d->m_owner = deSerializeString(is); d->m_infotext = deSerializeString(is); d->m_inventorydrawspec = deSerializeString(is); d->m_allow_text_input = readU8(is); d->m_removal_disabled = readU8(is); d->m_enforce_owner = readU8(is); int num_vars = readU32(is); for(int i=0; i<num_vars; i++){ std::string name = deSerializeString(is); std::string var = deSerializeLongString(is); d->m_stringvars[name] = var; } return d; }
void WP42DefineColumnsGroup::_readContents(librevenge::RVNGInputStream *input, WPXEncryption *encryption) { unsigned char maxNumColumns = 0; switch (m_groupId) { case WP42_DEFINE_COLUMNS_OLD_GROUP: input->seek(11, librevenge::RVNG_SEEK_CUR); maxNumColumns = 5; break; case WP42_DEFINE_COLUMNS_NEW_GROUP: input->seek(49, librevenge::RVNG_SEEK_CUR); maxNumColumns = 24; break; default: return; } unsigned char tmpNumColumns = readU8(input, encryption); m_numColumns = tmpNumColumns & 0x7F; if (m_numColumns > maxNumColumns) m_numColumns = maxNumColumns; m_isParallel = ((tmpNumColumns & 0x80) != 0); for (unsigned char i = 0; i<2*m_numColumns; i++) m_columnsDefinition.push_back(readU8(input, encryption)); }
void NameIdMapping::deSerialize(std::istream &is) { int version = readU8(is); if(version != 0) throw SerializationError("unsupported NameIdMapping version"); u32 count = readU16(is); m_id_to_name.clear(); m_name_to_id.clear(); for(u32 i=0; i<count; i++){ u16 id = readU16(is); std::string name = deSerializeString(is); m_id_to_name[id] = name; m_name_to_id[name] = id; } }
void CNodeDefManager::deSerialize(std::istream &is) { clear(); int version = readU8(is); if (version != 1) throw SerializationError("unsupported NodeDefinitionManager version"); u16 count = readU16(is); std::istringstream is2(deSerializeLongString(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::istringstream wrapper_is(wrapper, std::ios::binary); f.deSerialize(wrapper_is); // Check error conditions if (i == CONTENT_IGNORE || i == CONTENT_AIR || i == CONTENT_UNKNOWN) { warningstream << "NodeDefManager::deSerialize(): " "not changing builtin node " << i << std::endl; continue; } if (f.name.empty()) { warningstream << "NodeDefManager::deSerialize(): " "received empty name" << std::endl; continue; } // Ignore aliases u16 existing_id; if (m_name_id_mapping.getId(f.name, existing_id) && i != existing_id) { warningstream << "NodeDefManager::deSerialize(): " "already defined with different ID: " << f.name << std::endl; continue; } // All is ok, add node definition with the requested ID if (i >= m_content_features.size()) m_content_features.resize((u32)(i) + 1); m_content_features[i] = f; addNameIdMapping(i, f.name); verbosestream << "deserialized " << f.name << std::endl; getNodeBoxUnion(f.selection_box, f, &m_selection_box_union); fixSelectionBoxIntUnion(); } }
IWORKMemoryStream::IWORKMemoryStream(const RVNGInputStreamPtr_t &input) : m_data() , m_length(0) , m_pos(0) { const auto begin = (unsigned long) input->tell(); if (input->seek(0, librevenge::RVNG_SEEK_END)) { while (!input->isEnd()) readU8(input); } const auto end = (unsigned long) input->tell(); input->seek((long) begin, librevenge::RVNG_SEEK_SET); read(input, static_cast<unsigned>(end - begin)); }
void NodeTimerList::deSerialize(std::istream &is) { m_data.clear(); u8 version = readU8(is); if(version == 0) return; if(version != 1) throw SerializationError("unsupported NodeTimerList version"); u16 count = readU16(is); for(u16 i=0; i<count; i++) { u16 p16 = readU16(is); v3s16 p(0,0,0); p.Z += p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE; p16 -= p.Z * MAP_BLOCKSIZE * MAP_BLOCKSIZE; p.Y += p16 / MAP_BLOCKSIZE; p16 -= p.Y * MAP_BLOCKSIZE; p.X += p16; NodeTimer t; t.deSerialize(is); if(t.timeout <= 0) { infostream<<"WARNING: NodeTimerList::deSerialize(): " <<"invalid data at position" <<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring." <<std::endl; continue; } if(m_data.find(p) != m_data.end()) { infostream<<"WARNING: NodeTimerList::deSerialize(): " <<"already set data at position" <<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring." <<std::endl; continue; } m_data.insert(std::make_pair(p, t)); } }
virtual void deSerialize(std::istream &is) { // Clear everything clear(); // Deserialize int version = readU8(is); if(version != 0) throw SerializationError( "unsupported CraftDefManager version"); u16 count = readU16(is); for(u16 i=0; i<count; i++){ // Deserialize a string and grab a CraftDefinition from it std::istringstream tmp_is(deSerializeString(is), std::ios::binary); CraftDefinition *def = CraftDefinition::deSerialize(tmp_is); // Register registerCraft(def); } }
ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos, const std::string &data) { std::istringstream is(data, std::ios::binary); // read version u8 version = readU8(is); // check if version is supported if(version != 0) return NULL; // read name std::string name = deSerializeString(is); // read state std::string state = deSerializeLongString(is); // create object infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\"" <<state<<"\")"<<std::endl; return new LuaEntitySAO(env, pos, name, state); }
/************************************************************************************ * * ***********************************************************************************/ bool ScopeDome::SetupParms() { targetAz = 0; readU32(GetImpPerTurn, stepsPerTurn); LOGF_INFO("Steps per turn read as %d", stepsPerTurn); readS32(GetHomeSensorPosition, homePosition); LOGF_INFO("Home position read as %d", homePosition); if (UpdatePosition()) IDSetNumber(&DomeAbsPosNP, nullptr); if (UpdateShutterStatus()) IDSetSwitch(&DomeShutterSP, nullptr); UpdateSensorStatus(); UpdateRelayStatus(); if (InitPark()) { // If loading parking data is successful, we just set the default parking // values. SetAxis1ParkDefault(0); } else { // Otherwise, we set all parking data to default in case no parking data is // found. SetAxis1Park(0); SetAxis1ParkDefault(0); } uint16_t fwVersion; readU16(GetVersionFirmware, fwVersion); FirmwareVersionsN[0].value = fwVersion / 100.0; uint8_t fwVersionRotary; readU8(GetVersionFirmwareRotary, fwVersionRotary); FirmwareVersionsN[1].value = (fwVersionRotary + 9) / 10.0; FirmwareVersionsNP.s = IPS_OK; IDSetNumber(&FirmwareVersionsNP, nullptr); return true; }
void NodeMetadataList::deSerialize(std::istream &is, IGameDef *gamedef) { m_data.clear(); u8 version = readU8(is); if(version == 0){ // Nothing return; } if(version != 1){ infostream<<__FUNCTION_NAME<<": version "<<version<<" not supported" <<std::endl; throw SerializationError("NodeMetadataList::deSerialize"); } u16 count = readU16(is); for(u16 i=0; i<count; i++) { u16 p16 = readU16(is); v3s16 p; p.Z = p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE; p16 &= MAP_BLOCKSIZE * MAP_BLOCKSIZE - 1; p.Y = p16 / MAP_BLOCKSIZE; p16 &= MAP_BLOCKSIZE - 1; p.X = p16; if(m_data.find(p) != m_data.end()) { infostream<<"WARNING: NodeMetadataList::deSerialize(): " <<"already set data at position" <<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring." <<std::endl; continue; } NodeMetadata *data = new NodeMetadata(gamedef); data->deSerialize(is); m_data[p] = data; } }
void NodeMetadataList::deSerialize(std::istream &is, IItemDefManager *item_def_mgr) { clear(); u8 version = readU8(is); if (version == 0) { // Nothing return; } if (version != 1) { std::string err_str = std::string(FUNCTION_NAME) + ": version " + itos(version) + " not supported"; infostream << err_str << std::endl; throw SerializationError(err_str); } u16 count = readU16(is); for (u16 i=0; i < count; i++) { u16 p16 = readU16(is); v3s16 p; p.Z = p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE; p16 &= MAP_BLOCKSIZE * MAP_BLOCKSIZE - 1; p.Y = p16 / MAP_BLOCKSIZE; p16 &= MAP_BLOCKSIZE - 1; p.X = p16; if (m_data.find(p) != m_data.end()) { warningstream<<"NodeMetadataList::deSerialize(): " <<"already set data at position" <<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring." <<std::endl; continue; } NodeMetadata *data = new NodeMetadata(item_def_mgr); data->deSerialize(is); m_data[p] = data; } }
void AreaStore::deserialize(std::istream &is) { u8 ver = readU8(is); if (ver != 0) throw SerializationError("Unknown AreaStore " "serialization version!"); u16 num_areas = readU16(is); for (u32 i = 0; i < num_areas; ++i) { Area a; a.minedge = readV3S16(is); a.maxedge = readV3S16(is); u16 data_len = readU16(is); char *data = new char[data_len]; is.read(data, data_len); a.data = std::string(data, data_len); insertArea(&a); delete [] data; } }
void TestSerialization::testStreamRead() { std::string datastr( (const char *)test_serialized_data, sizeof(test_serialized_data)); std::istringstream is(datastr, std::ios_base::binary); UASSERT(readU8(is) == 0x11); UASSERT(readU16(is) == 0x2233); UASSERT(readU32(is) == 0x44556677); UASSERT(readU64(is) == 0x8899AABBCCDDEEFF); UASSERT(readS8(is) == -128); UASSERT(readS16(is) == 30000); UASSERT(readS32(is) == -6); UASSERT(readS64(is) == -43); UASSERT(readF1000(is) == 53.534f); UASSERT(readF1000(is) == -300000.32f); UASSERT(readF1000(is) == F1000_MIN); UASSERT(readF1000(is) == F1000_MAX); UASSERT(deSerializeString(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(readV2F1000(is) == v2f(500.656f, 350.345f)); 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(is.rdbuf()->in_avail() == 2); UASSERT(readU16(is) == 0xF00D); UASSERT(is.rdbuf()->in_avail() == 0); }
uv_err_t UVDData::compareEx(const UVDData *other, int *out) { uv_assert_ret(out); for( uint32_t i = 0; i < size() && i < other->size(); ++i ) { uint8_t cur = 0; uint8_t curOther = 0; uv_assert_err_ret(readU8(i, &cur)); uv_assert_err_ret(other->readU8(i, &curOther)); if( cur - curOther ) { *out = cur - curOther; return UV_ERR_OK; } } *out = size() - other->size(); return UV_ERR_OK; }
void WP1VariableLengthGroup::_read(librevenge::RVNGInputStream *input, WPXEncryption *encryption) { long startPosition = input->tell(); if (startPosition < 0) throw FileException(); WPD_DEBUG_MSG(("WordPerfect: handling a variable length group\n")); m_size = readU32(input, encryption, true); // the length is the number of data bytes minus 4 (ie. the function codes) if ((long)(m_size + startPosition) < startPosition) throw FileException(); WPD_DEBUG_MSG(("WordPerfect: Read variable group header (start_position: %li, size: %u)\n", startPosition, m_size)); _readContents(input, encryption); if ((m_size + (unsigned long)startPosition + 4 < m_size + (unsigned long)startPosition) || (m_size + (unsigned long)startPosition + 4) > ((std::numeric_limits<unsigned>::max)() / 2)) throw FileException(); input->seek(startPosition + m_size + 4, librevenge::RVNG_SEEK_SET); if (m_size != readU32(input, encryption, true)) { WPD_DEBUG_MSG(("WordPerfect: Possible corruption detected. Bailing out!\n")); throw FileException(); } if (m_group != readU8(input, encryption)) { WPD_DEBUG_MSG(("WordPerfect: Possible corruption detected. Bailing out!\n")); throw FileException(); } if ((m_size + (unsigned long)startPosition + 9 < m_size + (unsigned long)startPosition) || (m_size + (unsigned long)startPosition + 9) > ((std::numeric_limits<unsigned>::max)() / 2)) throw FileException(); input->seek(startPosition + m_size + 9, librevenge::RVNG_SEEK_SET); }
void WP1FixedLengthGroup::_read(librevenge::RVNGInputStream *input, WPXEncryption *encryption) { long startPosition = input->tell(); if (m_group >= 0xC0 && m_group <= 0xFE) // just an extra safety check { int size = WP1_FUNCTION_GROUP_SIZE[m_group-0xC0]; if (size == -1) return; _readContents(input, encryption); input->seek((startPosition + size - 2), librevenge::RVNG_SEEK_SET); if (m_group != readU8(input, encryption)) { WPD_DEBUG_MSG(("WordPerfect: Possible corruption detected. Bailing out!\n")); throw FileException(); } } else throw FileException(); }
void ToolCapabilities::deSerialize(std::istream &is) { int version = readU8(is); if(version != 0) throw SerializationError( "unsupported ToolCapabilities version"); full_punch_interval = readF1000(is); max_drop_level = readS16(is); groupcaps.clear(); u32 groupcaps_size = readU32(is); for(u32 i=0; i<groupcaps_size; i++){ std::string name = deSerializeString(is); ToolGroupCap cap; cap.maxwear = readF1000(is); cap.maxlevel = readF1000(is); u32 times_size = readU32(is); for(u32 i=0; i<times_size; i++){ int level = readS16(is); float time = readF1000(is); cap.times[level] = time; } groupcaps[name] = cap; } }
status WAVEFile::parseInstrument(const Tag &id, uint32_t size) { uint8_t baseNote; int8_t detune, gain; uint8_t lowNote, highNote, lowVelocity, highVelocity; uint8_t padByte; readU8(&baseNote); readS8(&detune); readS8(&gain); readU8(&lowNote); readU8(&highNote); readU8(&lowVelocity); readU8(&highVelocity); readU8(&padByte); return AF_SUCCEED; }
bool WP1VariableLengthGroup::isGroupConsistent(librevenge::RVNGInputStream *input, WPXEncryption *encryption, const unsigned char group) { long startPosition = input->tell(); if (startPosition < 0) throw FileException(); try { unsigned size = readU32(input, encryption, true); if (size > ((std::numeric_limits<unsigned>::max)() / 2)) return false; if (input->seek(size, librevenge::RVNG_SEEK_CUR) || input->isEnd()) { input->seek(startPosition, librevenge::RVNG_SEEK_SET); return false; } if (size != readU32(input, encryption, true)) { input->seek(startPosition, librevenge::RVNG_SEEK_SET); return false; } if (group != readU8(input, encryption)) { input->seek(startPosition, librevenge::RVNG_SEEK_SET); return false; } input->seek(startPosition, librevenge::RVNG_SEEK_SET); return true; } catch (...) { input->seek(startPosition, librevenge::RVNG_SEEK_SET); return false; } }
/************************************************************************************ * * ***********************************************************************************/ bool ScopeDome::UpdateSensorStatus() { readU8(GetLinkStrength, linkStrength); readFloat(GetAnalog1, sensors[0]); readFloat(GetAnalog2, sensors[1]); readFloat(GetMainAnalog1, sensors[2]); readFloat(GetMainAnalog2, sensors[3]); readFloat(GetTempIn, sensors[4]); readFloat(GetTempOut, sensors[5]); readFloat(GetTempHum, sensors[6]); readFloat(GetHum, sensors[7]); readFloat(GetPressure, sensors[8]); EnvironmentSensorsN[0].value = linkStrength; for (int i = 0; i < 9; ++i) { EnvironmentSensorsN[i + 1].value = sensors[i]; } EnvironmentSensorsN[10].value = getDewPoint(EnvironmentSensorsN[8].value, EnvironmentSensorsN[7].value); EnvironmentSensorsNP.s = IPS_OK; IDSetNumber(&EnvironmentSensorsNP, nullptr); return true; }
ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos, const std::string &data) { std::string name; std::string state; s16 hp = 1; v3f velocity; float yaw = 0; if(data != ""){ std::istringstream is(data, std::ios::binary); // read version u8 version = readU8(is); // check if version is supported if(version == 0){ name = deSerializeString(is); state = deSerializeLongString(is); } else if(version == 1){ name = deSerializeString(is); state = deSerializeLongString(is); hp = readS16(is); velocity = readV3F1000(is); yaw = readF1000(is); } } // create object /* infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\"" <<state<<"\")"<<std::endl; */ LuaEntitySAO *sao = new LuaEntitySAO(env, pos, name, state); sao->m_hp = hp; sao->m_velocity = velocity; sao->m_yaw = yaw; return sao; }
void ObjectProperties::deSerialize(std::istream &is) { int version = readU8(is); if(version == 1) { try{ hp_max = readS16(is); physical = readU8(is); weight = readF1000(is); collisionbox.MinEdge = readV3F1000(is); collisionbox.MaxEdge = readV3F1000(is); visual = deSerializeString(is); visual_size = readV2F1000(is); textures.clear(); u32 texture_count = readU16(is); for(u32 i=0; i<texture_count; i++){ textures.push_back(deSerializeString(is)); } spritediv = readV2S16(is); initial_sprite_basepos = readV2S16(is); is_visible = readU8(is); makes_footstep_sound = readU8(is); automatic_rotate = readF1000(is); mesh = deSerializeString(is); u32 color_count = readU16(is); for(u32 i=0; i<color_count; i++){ colors.push_back(readARGB8(is)); } collideWithObjects = readU8(is); stepheight = readF1000(is); automatic_face_movement_dir = readU8(is); automatic_face_movement_dir_offset = readF1000(is); }catch(SerializationError &e){} } else { throw SerializationError("unsupported ObjectProperties version"); } }
void MapBlock::deSerialize(std::istream &is, u8 version, bool disk) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapBlock format not supported"); TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())<<std::endl); m_day_night_differs_expired = false; if(version <= 21) { deSerialize_pre22(is, version, disk); return; } u8 flags = readU8(is); is_underground = (flags & 0x01) ? true : false; m_day_night_differs = (flags & 0x02) ? true : false; m_lighting_expired = (flags & 0x04) ? true : false; m_generated = (flags & 0x08) ? false : true; /* Bulk node data */ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos()) <<": Bulk node data"<<std::endl); u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; u8 content_width = readU8(is); u8 params_width = readU8(is); if(content_width != 1 && content_width != 2) throw SerializationError("MapBlock::deSerialize(): invalid content_width"); if(params_width != 2) throw SerializationError("MapBlock::deSerialize(): invalid params_width"); MapNode::deSerializeBulk(is, version, data, nodecount, content_width, params_width, true); /* NodeMetadata */ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos()) <<": Node metadata"<<std::endl); // Ignore errors try{ std::ostringstream oss(std::ios_base::binary); decompressZlib(is, oss); std::istringstream iss(oss.str(), std::ios_base::binary); if(version >= 23) m_node_metadata.deSerialize(iss, m_gamedef); else content_nodemeta_deserialize_legacy(iss, &m_node_metadata, &m_node_timers, m_gamedef); } catch(SerializationError &e) { errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error" <<" while deserializing node metadata at (" <<PP(getPos())<<": "<<e.what()<<std::endl; } /* Data that is only on disk */ if(disk) { // Node timers if(version == 23){ // Read unused zero readU8(is); } else if(version >= 24){ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos()) <<": Node timers"<<std::endl); m_node_timers.deSerialize(is); } // Static objects TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos()) <<": Static objects"<<std::endl); m_static_objects.deSerialize(is); // Timestamp TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos()) <<": Timestamp"<<std::endl); setTimestamp(readU32(is)); m_disk_timestamp = m_timestamp; // Dynamically re-set ids based on node names TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos()) <<": NameIdMapping"<<std::endl); NameIdMapping nimap; nimap.deSerialize(is); correctBlockNodeIds(&nimap, data, m_gamedef); }
void ContentFeatures::deSerializeOld(std::istream &is, int version) { if(version == 5) // In PROTOCOL_VERSION 13 { name = deSerializeString(is); groups.clear(); u32 groups_size = readU16(is); for(u32 i=0; i<groups_size; i++){ std::string name = deSerializeString(is); int value = readS16(is); groups[name] = value; } drawtype = (enum NodeDrawType)readU8(is); visual_scale = readF1000(is); if(readU8(is) != 6) throw SerializationError("unsupported tile count"); for(u32 i=0; i<6; i++) tiledef[i].deSerialize(is); if(readU8(is) != CF_SPECIAL_COUNT) throw SerializationError("unsupported CF_SPECIAL_COUNT"); for(u32 i=0; i<CF_SPECIAL_COUNT; i++) tiledef_special[i].deSerialize(is); alpha = readU8(is); post_effect_color.setAlpha(readU8(is)); post_effect_color.setRed(readU8(is)); post_effect_color.setGreen(readU8(is)); post_effect_color.setBlue(readU8(is)); param_type = (enum ContentParamType)readU8(is); param_type_2 = (enum ContentParamType2)readU8(is); is_ground_content = readU8(is); light_propagates = readU8(is); sunlight_propagates = readU8(is); walkable = readU8(is); pointable = readU8(is); diggable = readU8(is); climbable = readU8(is); buildable_to = readU8(is); deSerializeString(is); // legacy: used to be metadata_name liquid_type = (enum LiquidType)readU8(is); liquid_alternative_flowing = deSerializeString(is); liquid_alternative_source = deSerializeString(is); liquid_viscosity = readU8(is); light_source = readU8(is); damage_per_second = readU32(is); node_box.deSerialize(is); selection_box.deSerialize(is); legacy_facedir_simple = readU8(is); legacy_wallmounted = readU8(is); deSerializeSimpleSoundSpec(sound_footstep, is); deSerializeSimpleSoundSpec(sound_dig, is); deSerializeSimpleSoundSpec(sound_dug, is); } else { throw SerializationError("unsupported ContentFeatures version"); } }
void ContentFeatures::deSerialize(std::istream &is) { int version = readU8(is); if(version != 6){ deSerializeOld(is, version); return; } name = deSerializeString(is); groups.clear(); u32 groups_size = readU16(is); for(u32 i=0; i<groups_size; i++){ std::string name = deSerializeString(is); int value = readS16(is); groups[name] = value; } drawtype = (enum NodeDrawType)readU8(is); visual_scale = readF1000(is); if(readU8(is) != 6) throw SerializationError("unsupported tile count"); for(u32 i=0; i<6; i++) tiledef[i].deSerialize(is); if(readU8(is) != CF_SPECIAL_COUNT) throw SerializationError("unsupported CF_SPECIAL_COUNT"); for(u32 i=0; i<CF_SPECIAL_COUNT; i++) tiledef_special[i].deSerialize(is); alpha = readU8(is); post_effect_color.setAlpha(readU8(is)); post_effect_color.setRed(readU8(is)); post_effect_color.setGreen(readU8(is)); post_effect_color.setBlue(readU8(is)); param_type = (enum ContentParamType)readU8(is); param_type_2 = (enum ContentParamType2)readU8(is); is_ground_content = readU8(is); light_propagates = readU8(is); sunlight_propagates = readU8(is); walkable = readU8(is); pointable = readU8(is); diggable = readU8(is); climbable = readU8(is); buildable_to = readU8(is); deSerializeString(is); // legacy: used to be metadata_name liquid_type = (enum LiquidType)readU8(is); liquid_alternative_flowing = deSerializeString(is); liquid_alternative_source = deSerializeString(is); liquid_viscosity = readU8(is); liquid_renewable = readU8(is); light_source = readU8(is); damage_per_second = readU32(is); node_box.deSerialize(is); selection_box.deSerialize(is); legacy_facedir_simple = readU8(is); legacy_wallmounted = readU8(is); deSerializeSimpleSoundSpec(sound_footstep, is); deSerializeSimpleSoundSpec(sound_dig, is); deSerializeSimpleSoundSpec(sound_dug, is); rightclickable = readU8(is); drowning = readU8(is); leveled = readU8(is); liquid_range = readU8(is); // If you add anything here, insert it primarily inside the try-catch // block to not need to increase the version. try{ // Stuff below should be moved to correct place in a version that // otherwise changes the protocol version }catch(SerializationError &e) {}; }