Function LoadConfig

libs/uCommon/source/ul/cfg/cfg_Config.cpp:264–329

    }

    Config LoadConfig() {
        ConvertOldConfig();

        Config cfg = {};
        const auto config_path = os::IsEmuMMC() ? EmuMMCConfigPath : SysMMCConfigPath;
        const auto cfg_file_size = fs::GetFileSize(config_path);

        auto cfg_file_buf = new u8[cfg_file_size]();
        UL_ON_SCOPE_EXIT(
            delete[] cfg_file_buf;
        );

        if(fs::ReadFile(config_path, cfg_file_buf, cfg_file_size)) {
            size_t cur_offset = 0;
            const auto cfg_header = *reinterpret_cast<ConfigHeader*>(cfg_file_buf);
            if(cfg_header.magic == ConfigHeader::Magic) {
                cur_offset += sizeof(ConfigHeader);
                if(cur_offset <= cfg_file_size) {
                    cfg.entries.reserve(cfg_header.entry_count);
                    for(u32 i = 0; i < cfg_header.entry_count; i++) {
                        ConfigEntry ent = {};
                        ent.header = *reinterpret_cast<ConfigEntryHeader*>(cfg_file_buf + cur_offset);
                        cur_offset += sizeof(ConfigEntryHeader);
                        if(cur_offset > cfg_file_size) {
                            break;
                        }
                        switch(ent.header.type) {
                            case ConfigEntryType::Bool: {
                                if(ent.header.size != sizeof(bool)) {
                                    return CreateNewAndLoadConfig();
                                }
                                ent.bool_value = *reinterpret_cast<bool*>(cfg_file_buf + cur_offset);
                                break;
                            }
                            case ConfigEntryType::U64: {
                                if(ent.header.size != sizeof(u64)) {
                                    return CreateNewAndLoadConfig();
                                }
                                ent.u64_value = *reinterpret_cast<u64*>(cfg_file_buf + cur_offset);
                                break;
                            }
                            case ConfigEntryType::String: {
                                if(ent.header.size == 0) {
                                    ent.str_value = "";
                                }
                                else {
                                    ent.str_value = std::string(reinterpret_cast<char*>(cfg_file_buf + cur_offset), ent.header.size);
                                }
                                break;
                            }
                        }
                        cur_offset += ent.header.size;
                        if(cur_offset > cfg_file_size) {
                            break;
                        }
                        cfg.entries.push_back(std::move(ent));
                    }
                    if(cur_offset <= cfg_file_size) {