Skip to content
TheChatArchiveThe Chat Archive
Coherecommand-a-03-2025· CohereHugging Face Arena Expert 5K

how can i deserialize entt meta correctly? [code]

  1. User

    how can i deserialize entt meta correctly?

    void AssetManager::RegisterAssetsMetadata()
    {
    	entt::meta_factory<BaseAsset>()
    		.type(entt::type_hash<BaseAsset>::value(), "Asset")
    		.data<&BaseAsset::guid>("GUID"_hs, "GUID")
    		.data<&BaseAsset::lastModified>("lastModified"_hs, "lastModified")
    		.data<&BaseAsset::sourceFilePath>("sourceFilePath"_hs, "sourceFilePath");
    
    	entt::meta_factory<TextureAsset>()
    		.type(entt::type_hash<TextureAsset>::value(), "Texture Asset")
    		.base<BaseAsset>() // register base class
    		.data<&TextureAsset::compressionFormats>("compressionFormats"_hs, "compressionFormats")
    		.data<&TextureAsset::mipmapsLevel>("mipmapsLevel"_hs, "mipmapsLevel")
    		.data<&TextureAsset::filterMode>("filterMode"_hs, "filterMode")
    		.data<&TextureAsset::wrapMode>("wrapMode"_hs, "wrapMode");
    }
    
    void AssetManager::SerializeAssetsMetadata(std::unique_ptr<BaseAsset> const& _asset, AssetType _type)
    {
    	std::string filename = _asset->sourceFilePath.string() + m_AssetMetadataExt;
    	std::ofstream metafile(filename); if (!metafile.is_open()) { return; }
    
    	// wrap data in meta_any
    	entt::meta_any assetmetadata{ *_asset };
    
    	for (auto&& [id, data] : assetmetadata.type().data())
    		{
    			auto typeID = data.type().id();
    
    			if (entt::resolve<xresource::full_guid>().id() == typeID)
    			{
    				if (xresource::full_guid* ptr = data.get(assetmetadata).try_cast<xresource::full_guid>())
    				{
    					metafile << data.name() << " " << "Type="; metafile << ptr->m_Type.m_Value << '\n';
    					metafile << data.name() << " " << "Instance="; metafile << ptr->m_Instance.m_Value << '\n';
    				}
    			}
    			else if (entt::resolve<fs::file_time_type>().id() == typeID)
    			{
    				if (fs::file_time_type* ptr = data.get(assetmetadata).try_cast<fs::file_time_type>())
    				{
    					metafile << data.name() << "=";
    					metafile << *ptr << '\n';
    				}
    			}
    			else if (entt::resolve<fs::path>().id() == typeID)
    			{
    				if (data.get(assetmetadata).try_cast<fs::path>())
    				{
    					metafile << data.name() << "=";
    					fs::path tmp = *data.get(assetmetadata).try_cast<fs::path>();
    					metafile << tmp.string() << '\n';
    				}
    			}
    		}
    	
    
    	switch (_type)
    	{
    	case TEXTURE: assetmetadata = dynamic_cast<TextureAsset&>(*_asset); break;
    	};
    
    	for (auto&& [id, data] : assetmetadata.type().data())
    	{
    			auto typeID = data.type().id();
    
    			if (entt::resolve<int>().id() == typeID)
    			{
    				if (int* ptr = data.get(assetmetadata).try_cast<int>())
    				{
    					metafile << data.name() << "=";
    					metafile << *ptr << '\n';
    				}
    			}
    			else if (entt::resolve<TextureAsset::TextureCompression>().id() == typeID)
    			{
    				if (TextureAsset::TextureCompression* ptr = data.get(assetmetadata).try_cast<TextureAsset::TextureCompression>())
    				{
    					metafile << data.name() << "=";
    
    					metafile << EnumToString(*ptr) << '\n';
    				}
    			}
    			else if (entt::resolve<TextureAsset::TextureFilter>().id() == typeID)
    			{
    				if (TextureAsset::TextureFilter* ptr = data.get(assetmetadata).try_cast<TextureAsset::TextureFilter>())
    				{
    					metafile << data.name() << "=";
    					metafile << EnumToString(*ptr) << '\n';
    				}
    			}
    			else if (entt::resolve<TextureAsset::TextureWrap>().id() == typeID)
    			{
    				if (TextureAsset::TextureWrap* ptr = data.get(assetmetadata).try_cast<TextureAsset::TextureWrap>())
    				{
    					metafile << data.name() << "=";
    					metafile << EnumToString(*ptr) << '\n';
    				}
    			}
    		}
    }
    
    AssetType AssetManager::DeserializeAssetsMetadata(std::filesystem::path _path, std::unique_ptr<BaseAsset> const& _asset)
    {
    	// read .meta file
    	std::ifstream metafile(_path); if (!metafile.is_open()) { return UNKNOWN; }
    
    	entt::meta_type assetType = entt::resolve(entt::hashed_string{ "Asset" });
    
    	for (std::string line; std::getline(metafile, line, '='); )
    	{
    		entt::meta_type type = entt::resolve(entt::hashed_string{ line.c_str() });
    		// to refactor .. same as inspector
    			if (entt::resolve<xresource::full_guid>().name() == line)
    			{
    				xresource::type_guid type; xresource::instance_guid instance;
    				std::getline(metafile, line, '='); std::getline(metafile, line, '=');
    				std::istringstream iss{ line };
    				iss >> type.m_Value;
    				std::getline(metafile, line, '='); std::getline(metafile, line, '=');
    				iss.clear(); iss.str(line);
    				iss >> instance.m_Value;
    
    				_asset->guid = { instance,type };
    			}
    			if (entt::resolve<fs::file_time_type>().name() == line)
    			{
    				std::getline(metafile, line, '=');
    				std::istringstream iss{ line };
    				std::cout << line << std::endl;
    				std::chrono::system_clock::time_point sys_tp;
    				iss >> std::chrono::parse("%F %T", sys_tp);
    				if (iss.fail()) { std::cerr << "Failed to parse time string." << std::endl; }
    				_asset->lastModified = std::chrono::clock_cast<std::chrono::file_clock>(sys_tp);
    			}
    
    		std::cout << line << std::endl;
    	}
    	std::cout << _asset->lastModified << std::endl;
    	if (TextureAsset::typeGUID.m_Value == _asset->guid.m_Type.m_Value) {  return TEXTURE; }
    
    	return UNKNOWN;
    }
    
  2. Cohere Assistant

    Deserializing entt::meta data correctly involves ensuring that the serialized data is read back into the appropriate fields of the asset objects. Your current implementation has a few areas that can be improved for robustness and clarity. Below is a refactored and corrected version of your DeserializeAssetsMetadata function, along with some suggestions for improvement:

    Refactored DeserializeAssetsMetadata Function

    AssetType AssetManager::DeserializeAssetsMetadata(std::filesystem::path _path, std::unique_ptr<BaseAsset>& _asset)
    {
        // Read .meta file
        std::ifstream metafile(_path);
        if (!metafile.is_open()) {
            return UNKNOWN;
        }
    
        std::string line;
        while (std::getline(metafile, line)) {
            if (line.empty()) continue; // Skip empty lines
    
            size_t equalsPos = line.find('=');
            if (equalsPos == std::string::npos) continue; // Skip malformed lines
    
            std::string key = line.substr(0, equalsPos);
            std::string value = line.substr(equalsPos + 1);
    
            // Trim whitespace from key and value
            key.erase(0, key.find_first_not_of(" \t"));
            key.erase(key.find_last_not_of(" \t") + 1);
            value.erase(0, value.find_first_not_of(" \t"));
            value.erase(value.find_last_not_of(" \t") + 1);
    
            // Handle GUID
            if (key == entt::resolve<xresource::full_guid>().name()) {
                size_t typePos = value.find("Type=");
                size_t instancePos = value.find("Instance=");
    
                if (typePos != std::string::npos && instancePos != std::string::npos) {
                    xresource::type_guid type;
                    xresource::instance_guid instance;
    
                    type.m_Value = std::stoull(value.substr(typePos + 5, instancePos - typePos - 5));
                    instance.m_Value = std::stoull(value.substr(instancePos + 9));
    
                    _asset->guid = { instance, type };
                }
            }
            // Handle file time
            else if (key == entt::resolve<fs::file_time_type>().name()) {
                std::istringstream iss(value);
                std::chrono::system_clock::time_point sys_tp;
                iss >> std::chrono::parse("%F %T", sys_tp);
    
                if (!iss.fail()) {
                    _asset->lastModified = std::chrono::clock_cast<std::chrono::file_clock>(sys_tp);
                } else {
                    std::cerr << "Failed to parse time string: " << value << std::endl;
                }
            }
            // Handle file path
            else if (key == entt::resolve<fs::path>().name()) {
                _asset->sourceFilePath = value;
            }
            // Handle TextureAsset specific fields
            else if (auto textureAsset = dynamic_cast<TextureAsset*>(_asset.get())) {
                if (key == "compressionFormats") {
                    textureAsset->compressionFormats = StringToEnum<TextureAsset::TextureCompression>(value);
                }
                else if (key == "mipmapsLevel") {
                    textureAsset->mipmapsLevel = std::stoi(value);
                }
                else if (key == "filterMode") {
                    textureAsset->filterMode = StringToEnum<TextureAsset::TextureFilter>(value);
                }
                else if (key == "wrapMode") {
                    textureAsset->wrapMode = StringToEnum<TextureAsset::TextureWrap>(value);
                }
            }
        }
    
        // Determine asset type based on GUID
        if (TextureAsset::typeGUID.m_Value == _asset->guid.m_Type.m_Value) {
            return TEXTURE;
        }
    
        return UNKNOWN;
    }
    

    Key Improvements and Suggestions

    1. Error Handling: Added checks for malformed lines and parsing errors, with appropriate error messages.
    2. Whitespace Trimming: Trimmed whitespace from keys and values to handle potential formatting issues.
    3. Type Determination: Moved the asset type determination to the end of the function after all fields are deserialized.
    4. Enum Parsing: Introduced a helper function StringToEnum to convert string values back to enums. This assumes you have a similar function as EnumToString for serialization.
    5. Dynamic Casting: Used dynamic_cast to handle TextureAsset-specific fields only if the asset is of the correct type.

    Helper Function for Enum Conversion

    template<typename EnumType>
    EnumType StringToEnum(const std::string& str) {
        // Implement logic to convert string to enum
        // Example for TextureCompression:
        if (str == "EnumValue1") return EnumType::EnumValue1;
        if (str == "EnumValue2") return EnumType::EnumValue2;
        // ... handle other cases
        throw std::invalid_argument("Unknown enum value: " + str);
    }
    

    Additional Considerations

    • Serialization Format: Ensure the serialization format is consistent and well-defined. Consider using a more structured format like JSON or binary serialization for easier parsing.
    • Type Safety: Use entt::meta more extensively to handle type-safe serialization and deserialization, especially for complex types.
    • Polymorphism: If you have a hierarchy of assets, consider using a factory pattern or virtual functions to handle deserialization based on the asset type.

    This refactored code should provide a more robust and maintainable solution for deserializing your asset metadata.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.