|
|
/*
|
|
|
Copyright 2021 Peter Repukat - FlatspotSoftware
|
|
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
you may not use this file except in compliance with the License.
|
|
|
You may obtain a copy of the License at
|
|
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
See the License for the specific language governing permissions and
|
|
|
limitations under the License.
|
|
|
*/
|
|
|
|
|
|
// "Shitty shortcuts.vdf Parser"<22>
|
|
|
|
|
|
#pragma once
|
|
|
#include <charconv>
|
|
|
#include <filesystem>
|
|
|
#include <fstream>
|
|
|
#include <iostream>
|
|
|
#include <string>
|
|
|
#include <vector>
|
|
|
|
|
|
namespace VDFParser {
|
|
|
namespace crc {
|
|
|
template <typename CONT>
|
|
|
uint32_t calculate_crc(CONT container)
|
|
|
{
|
|
|
uint32_t crc32_table[256];
|
|
|
for (uint32_t i = 0; i < 256; i++) {
|
|
|
uint32_t ch = i;
|
|
|
uint32_t crc = 0;
|
|
|
for (size_t j = 0; j < 8; j++) {
|
|
|
uint32_t b = (ch ^ crc) & 1;
|
|
|
crc >>= 1;
|
|
|
if (b)
|
|
|
crc = crc ^ 0xEDB88320;
|
|
|
ch >>= 1;
|
|
|
}
|
|
|
crc32_table[i] = crc;
|
|
|
}
|
|
|
uint32_t crc = 0xFFFFFFFF;
|
|
|
for (size_t i = 0; i < container.size(); i++) {
|
|
|
char ch = container.data()[i];
|
|
|
uint32_t t = (ch ^ crc) & 0xFF;
|
|
|
crc = (crc >> 8) ^ crc32_table[t];
|
|
|
}
|
|
|
return ~crc;
|
|
|
}
|
|
|
} // namespace crc
|
|
|
|
|
|
static constexpr const char k_appid[] = {"appid"};
|
|
|
static constexpr const char k_appname[] = {"appname"};
|
|
|
static constexpr const char k_exe[] = {"exe"};
|
|
|
static constexpr const char k_StartDir[] = {"StartDir"};
|
|
|
static constexpr const char k_icon[] = {"icon"};
|
|
|
static constexpr const char k_ShortcutPath[] = {"ShortcutPath"};
|
|
|
static constexpr const char k_LaunchOptions[] = {"LaunchOptions"};
|
|
|
static constexpr const char k_IsHidden[] = {"IsHidden"};
|
|
|
static constexpr const char k_AllowDesktopConfig[] = {"AllowDesktopConfig"};
|
|
|
static constexpr const char k_AllowOverlay[] = {"AllowOverlay"};
|
|
|
static constexpr const char k_openvr[] = {"openvr"};
|
|
|
static constexpr const char k_Devkit[] = {"Devkit"};
|
|
|
static constexpr const char k_DevkitGameID[] = {"DevkitGameID"};
|
|
|
static constexpr const char k_DevkitOverrideAppID[] = {"DevkitOverrideAppID"};
|
|
|
static constexpr const char k_LastPlayTime[] = {"LastPlayTime"};
|
|
|
static constexpr const char k_tags[] = {"tags"};
|
|
|
|
|
|
enum VDFTypeId {
|
|
|
StringList = 0,
|
|
|
String,
|
|
|
Number,
|
|
|
};
|
|
|
|
|
|
template <const char* const keyname, typename type, const uint8_t const _type_id>
|
|
|
struct VDFKeyPair {
|
|
|
VDFKeyPair() {}
|
|
|
explicit VDFKeyPair(type _value) : value(_value) {}
|
|
|
static constexpr uint8_t _TID = _type_id;
|
|
|
static constexpr const char* const _KEY = keyname;
|
|
|
const uint8_t type_id = _TID;
|
|
|
const char* const key = _KEY;
|
|
|
type value;
|
|
|
VDFKeyPair(const VDFKeyPair& other)
|
|
|
{
|
|
|
value = other.value;
|
|
|
};
|
|
|
VDFKeyPair(VDFKeyPair&& other)
|
|
|
{
|
|
|
value = std::move(other.value);
|
|
|
};
|
|
|
VDFKeyPair& operator=(const VDFKeyPair& other)
|
|
|
{
|
|
|
value = other.value;
|
|
|
return *this;
|
|
|
}
|
|
|
VDFKeyPair& operator=(VDFKeyPair&& other)
|
|
|
{
|
|
|
value = std::move(other.value);
|
|
|
return *this;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
template <uint8_t initialByte>
|
|
|
struct VDFIdx {
|
|
|
VDFIdx(){};
|
|
|
VDFIdx(const VDFIdx& other)
|
|
|
{
|
|
|
data[0] = other.data[0];
|
|
|
data[1] = other.data[1];
|
|
|
};
|
|
|
VDFIdx(VDFIdx&& other)
|
|
|
{
|
|
|
data[0] = std::move(other.data[0]);
|
|
|
data[1] = std::move(other.data[1]);
|
|
|
};
|
|
|
VDFIdx(int idx)
|
|
|
{
|
|
|
if (idx > 99) {
|
|
|
data[0] = initialByte;
|
|
|
data[1] = 0;
|
|
|
}
|
|
|
else if (idx < 10) {
|
|
|
data[1] = std::to_string(idx).c_str()[0];
|
|
|
}
|
|
|
else {
|
|
|
auto meh = std::to_string(idx).c_str();
|
|
|
data[0] = meh[0] + initialByte;
|
|
|
data[1] = meh[1];
|
|
|
}
|
|
|
}
|
|
|
char data[2] = {initialByte, 0x0};
|
|
|
operator int() const
|
|
|
{
|
|
|
if (data[0] == initialByte) {
|
|
|
int res = 0;
|
|
|
std::from_chars(&data[1], &data[1], res);
|
|
|
return res;
|
|
|
}
|
|
|
int res = 0;
|
|
|
char copy[2] = {data[0] - initialByte, data[1]};
|
|
|
std::from_chars(©[0], ©[1], res);
|
|
|
return res;
|
|
|
}
|
|
|
|
|
|
VDFIdx& operator=(const VDFIdx& other)
|
|
|
{
|
|
|
data[0] = other.data[0];
|
|
|
data[1] = other.data[1];
|
|
|
return *this;
|
|
|
}
|
|
|
VDFIdx& operator=(VDFIdx&& other)
|
|
|
{
|
|
|
data[0] = std::move(other.data[0]);
|
|
|
data[1] = std::move(other.data[1]);
|
|
|
return *this;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
struct ShortcutTag {
|
|
|
ShortcutTag(){};
|
|
|
ShortcutTag(const ShortcutTag& other)
|
|
|
{
|
|
|
value = other.value;
|
|
|
};
|
|
|
ShortcutTag(ShortcutTag&& other)
|
|
|
{
|
|
|
value = std::move(other.value);
|
|
|
};
|
|
|
VDFIdx<0x01> idx; // I Hope this is how it works... See VDFIdx
|
|
|
std::string value;
|
|
|
const uint16_t end_marker = 0x0808;
|
|
|
|
|
|
ShortcutTag& operator=(const ShortcutTag& other)
|
|
|
{
|
|
|
value = other.value;
|
|
|
return *this;
|
|
|
}
|
|
|
ShortcutTag& operator=(ShortcutTag&& other)
|
|
|
{
|
|
|
value = std::move(other.value);
|
|
|
return *this;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
struct Shortcut {
|
|
|
VDFIdx<0x00> idx;
|
|
|
VDFKeyPair<k_appid, uint32_t, VDFTypeId::Number> appId{0x000000};
|
|
|
VDFKeyPair<k_appname, std::string, VDFTypeId::String> appName{""};
|
|
|
VDFKeyPair<k_exe, std::string, VDFTypeId::String> exe{"\"\""}; // Qouted
|
|
|
VDFKeyPair<k_StartDir, std::string, VDFTypeId::String> StartDir{"\"\""}; // Qouted
|
|
|
VDFKeyPair<k_icon, std::string, VDFTypeId::String> icon{""}; // Qouted or empty
|
|
|
VDFKeyPair<k_ShortcutPath, std::string, VDFTypeId::String> ShortcutPath{""}; // Qouted or empty?
|
|
|
VDFKeyPair<k_LaunchOptions, std::string, VDFTypeId::String> LaunchOptions{""}; // UNQOUTED or empty
|
|
|
VDFKeyPair<k_IsHidden, uint32_t, VDFTypeId::Number> IsHidden{0};
|
|
|
VDFKeyPair<k_AllowDesktopConfig, uint32_t, VDFTypeId::Number> AllowDesktopConfig{1};
|
|
|
VDFKeyPair<k_AllowOverlay, uint32_t, VDFTypeId::Number> AllowOverlay{1};
|
|
|
VDFKeyPair<k_openvr, uint32_t, VDFTypeId::Number> openvr{0};
|
|
|
VDFKeyPair<k_Devkit, uint32_t, VDFTypeId::Number> Devkit{0};
|
|
|
VDFKeyPair<k_DevkitGameID, std::string, VDFTypeId::String> DevkitGameID{""};
|
|
|
VDFKeyPair<k_DevkitOverrideAppID, uint32_t, VDFTypeId::Number> DevkitOverrideAppID{0}; //
|
|
|
VDFKeyPair<k_LastPlayTime, uint32_t, VDFTypeId::Number> LastPlayTime{0}; //
|
|
|
VDFKeyPair<k_tags, std::vector<ShortcutTag>, VDFTypeId::StringList> tags{};
|
|
|
Shortcut& operator=(const Shortcut& other)
|
|
|
{
|
|
|
idx = other.idx;
|
|
|
appId = other.appId;
|
|
|
appName = other.appName;
|
|
|
exe = other.exe;
|
|
|
StartDir = other.StartDir;
|
|
|
icon = other.icon;
|
|
|
ShortcutPath = other.ShortcutPath;
|
|
|
LaunchOptions = other.LaunchOptions;
|
|
|
LaunchOptions = other.LaunchOptions;
|
|
|
IsHidden = other.IsHidden;
|
|
|
AllowDesktopConfig = other.AllowDesktopConfig;
|
|
|
AllowOverlay = other.AllowOverlay;
|
|
|
openvr = other.openvr;
|
|
|
Devkit = other.Devkit;
|
|
|
DevkitGameID = other.DevkitGameID;
|
|
|
DevkitOverrideAppID = other.DevkitOverrideAppID;
|
|
|
LastPlayTime = other.LastPlayTime;
|
|
|
tags = other.tags;
|
|
|
return *this;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
struct VDFFile {
|
|
|
VDFFile(){};
|
|
|
VDFFile(const VDFFile& other)
|
|
|
{
|
|
|
shortcuts = other.shortcuts;
|
|
|
};
|
|
|
VDFFile(VDFFile&& other)
|
|
|
{
|
|
|
shortcuts = std::move(other.shortcuts);
|
|
|
};
|
|
|
const uint8_t first_byte = 0x00;
|
|
|
const std::string identifier = "shortcuts";
|
|
|
std::vector<Shortcut> shortcuts;
|
|
|
const uint16_t end_marker = 0x0808;
|
|
|
VDFFile& operator=(const VDFFile& other)
|
|
|
{
|
|
|
shortcuts = other.shortcuts;
|
|
|
return *this;
|
|
|
}
|
|
|
VDFFile& operator=(VDFFile&& other)
|
|
|
{
|
|
|
shortcuts = std::move(other.shortcuts);
|
|
|
return *this;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
class Parser {
|
|
|
private:
|
|
|
static inline std::ifstream ifile;
|
|
|
static inline std::ofstream ofile;
|
|
|
|
|
|
template <typename typ, typename size>
|
|
|
static inline auto readVDFBuffer(typ& buff, size sz)
|
|
|
{
|
|
|
if (ifile.eof()) {
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
ifile.read((char*)buff, sz);
|
|
|
}
|
|
|
|
|
|
template <typename typ>
|
|
|
static inline auto readVDFValue()
|
|
|
{
|
|
|
uint8_t buff[sizeof(typ)];
|
|
|
ifile.read((char*)buff, sizeof(typ));
|
|
|
return *reinterpret_cast<typ*>(buff);
|
|
|
}
|
|
|
|
|
|
static inline std::string readVDFString()
|
|
|
{
|
|
|
std::string str;
|
|
|
char ch = '\x0';
|
|
|
do {
|
|
|
if (ifile.eof()) {
|
|
|
return str;
|
|
|
}
|
|
|
ifile.read(&ch, sizeof(char));
|
|
|
if (ch != '\x0')
|
|
|
str.push_back(ch);
|
|
|
} while (ch != '\x0');
|
|
|
return str;
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
static inline uint32_t calculateAppId(const Shortcut& shortcut)
|
|
|
{
|
|
|
std::string buff = shortcut.exe.value + shortcut.appName.value;
|
|
|
auto checksum = crc::calculate_crc(buff);
|
|
|
return checksum | 0x80000000;
|
|
|
}
|
|
|
|
|
|
static inline VDFFile parseShortcuts(std::filesystem::path path)
|
|
|
{
|
|
|
VDFFile vdffile;
|
|
|
|
|
|
ifile.open(path.string(), std::ios::binary | std::ios::in);
|
|
|
if (!ifile.is_open()) {
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
auto firsty = readVDFValue<uint8_t>();
|
|
|
if (vdffile.first_byte != firsty) {
|
|
|
// TODO: invalid
|
|
|
ifile.close();
|
|
|
return vdffile;
|
|
|
}
|
|
|
|
|
|
auto headername = readVDFString();
|
|
|
if (vdffile.identifier != headername) {
|
|
|
// TODO: invalid
|
|
|
ifile.close();
|
|
|
return vdffile;
|
|
|
}
|
|
|
|
|
|
char buff[3];
|
|
|
while (true) {
|
|
|
if (ifile.eof()) {
|
|
|
break;
|
|
|
}
|
|
|
readVDFBuffer(buff, 3); // 2 bytes idx, 0x00 delmiter
|
|
|
if (buff[0] == 0x08 && buff[1] == 0x08) {
|
|
|
break;
|
|
|
}
|
|
|
Shortcut shortcut;
|
|
|
shortcut.idx.data[0] = buff[0];
|
|
|
shortcut.idx.data[1] = buff[1];
|
|
|
while (true) // TODO;
|
|
|
{
|
|
|
if (ifile.eof()) {
|
|
|
break;
|
|
|
}
|
|
|
VDFTypeId tid = static_cast<VDFTypeId>(readVDFValue<uint8_t>());
|
|
|
if (tid == 0x08) {
|
|
|
auto nextbyte = readVDFValue<uint8_t>();
|
|
|
if (nextbyte == 0x08) {
|
|
|
break;
|
|
|
}
|
|
|
else {
|
|
|
// WTF?!
|
|
|
// TODO:
|
|
|
throw std::exception("WTF");
|
|
|
}
|
|
|
}
|
|
|
auto key = readVDFString();
|
|
|
if ((tid == 0x08 && key[0] == 0x08) || key == "\x08\x08") {
|
|
|
break;
|
|
|
}
|
|
|
if (key == shortcut.appId.key) {
|
|
|
shortcut.appId.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.appName.key) {
|
|
|
shortcut.appName.value = readVDFString();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.exe.key) {
|
|
|
shortcut.exe.value = readVDFString();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.StartDir.key) {
|
|
|
shortcut.StartDir.value = readVDFString();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.icon.key) {
|
|
|
shortcut.icon.value = readVDFString();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.ShortcutPath.key) {
|
|
|
shortcut.ShortcutPath.value = readVDFString();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.LaunchOptions.key) {
|
|
|
shortcut.LaunchOptions.value = readVDFString();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.IsHidden.key) {
|
|
|
shortcut.IsHidden.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.AllowDesktopConfig.key) {
|
|
|
shortcut.AllowDesktopConfig.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.AllowOverlay.key) {
|
|
|
shortcut.AllowOverlay.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.openvr.key) {
|
|
|
shortcut.openvr.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.Devkit.key) {
|
|
|
shortcut.Devkit.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.DevkitGameID.key) {
|
|
|
shortcut.DevkitGameID.value = readVDFString();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.DevkitOverrideAppID.key) {
|
|
|
shortcut.DevkitOverrideAppID.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.LastPlayTime.key) {
|
|
|
shortcut.LastPlayTime.value = readVDFValue<uint32_t>();
|
|
|
continue;
|
|
|
}
|
|
|
if (key == shortcut.tags.key) {
|
|
|
// TODO: read tags
|
|
|
ShortcutTag tag;
|
|
|
while (true) {
|
|
|
if (ifile.eof()) {
|
|
|
break;
|
|
|
}
|
|
|
char tbuff[2];
|
|
|
readVDFBuffer(tbuff, 2); // 2 bytes idx
|
|
|
if (tbuff[0] == 0x08 && tbuff[1] == 0x08) {
|
|
|
ifile.seekg(-2, std::ios_base::cur);
|
|
|
break;
|
|
|
}
|
|
|
tag.idx.data[0] = tbuff[0];
|
|
|
tag.idx.data[1] = tbuff[1];
|
|
|
ifile.seekg(1, std::ios_base::cur);
|
|
|
tag.value = readVDFString();
|
|
|
shortcut.tags.value.push_back(tag);
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
if (!(shortcut.idx.data[0] == 0x0 && shortcut.idx.data[1] == 0x0)) {
|
|
|
vdffile.shortcuts.push_back(shortcut);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ifile.close();
|
|
|
|
|
|
return vdffile;
|
|
|
}
|
|
|
|
|
|
static inline bool writeShortcuts(std::filesystem::path path, const VDFFile& vdffile)
|
|
|
{
|
|
|
ofile.open(path.string(), std::ios::binary | std::ios::out);
|
|
|
if (!ofile.is_open()) {
|
|
|
return false;
|
|
|
}
|
|
|
ofile.write((char*)&vdffile.first_byte, 1);
|
|
|
ofile.write(vdffile.identifier.data(), vdffile.identifier.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
for (auto& shortcut : vdffile.shortcuts) {
|
|
|
ofile.write(shortcut.idx.data, 2);
|
|
|
ofile.write("\x00", 1);
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.appId.type_id, 1);
|
|
|
ofile.write(shortcut.appId.key, 6);
|
|
|
ofile.write((char*)&shortcut.appId.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.appName.type_id, 1);
|
|
|
ofile.write(shortcut.appName.key, 8);
|
|
|
ofile.write(shortcut.appName.value.data(), shortcut.appName.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.exe.type_id, 1);
|
|
|
ofile.write(shortcut.exe.key, 4);
|
|
|
ofile.write(shortcut.exe.value.data(), shortcut.exe.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.StartDir.type_id, 1);
|
|
|
ofile.write(shortcut.StartDir.key, 9);
|
|
|
ofile.write(shortcut.StartDir.value.data(), shortcut.StartDir.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.icon.type_id, 1);
|
|
|
ofile.write(shortcut.icon.key, 5);
|
|
|
ofile.write(shortcut.icon.value.data(), shortcut.icon.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.ShortcutPath.type_id, 1);
|
|
|
ofile.write(shortcut.ShortcutPath.key, 13);
|
|
|
ofile.write(shortcut.ShortcutPath.value.data(), shortcut.ShortcutPath.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.LaunchOptions.type_id, 1);
|
|
|
ofile.write(shortcut.LaunchOptions.key, 14);
|
|
|
ofile.write(shortcut.LaunchOptions.value.data(), shortcut.LaunchOptions.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.IsHidden.type_id, 1);
|
|
|
ofile.write(shortcut.IsHidden.key, 9);
|
|
|
ofile.write((char*)&shortcut.IsHidden.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.AllowDesktopConfig.type_id, 1);
|
|
|
ofile.write(shortcut.AllowDesktopConfig.key, 19);
|
|
|
ofile.write((char*)&shortcut.AllowDesktopConfig.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.AllowOverlay.type_id, 1);
|
|
|
ofile.write(shortcut.AllowOverlay.key, 13);
|
|
|
ofile.write((char*)&shortcut.AllowOverlay.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.openvr.type_id, 1);
|
|
|
ofile.write(shortcut.openvr.key, 7);
|
|
|
ofile.write((char*)&shortcut.openvr.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.Devkit.type_id, 1);
|
|
|
ofile.write(shortcut.Devkit.key, 7);
|
|
|
ofile.write((char*)&shortcut.Devkit.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.DevkitGameID.type_id, 1);
|
|
|
ofile.write(shortcut.DevkitGameID.key, 13);
|
|
|
ofile.write(shortcut.DevkitGameID.value.data(), shortcut.DevkitGameID.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.DevkitOverrideAppID.type_id, 1);
|
|
|
ofile.write(shortcut.DevkitOverrideAppID.key, 20);
|
|
|
ofile.write((char*)&shortcut.DevkitOverrideAppID.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.LastPlayTime.type_id, 1);
|
|
|
ofile.write(shortcut.LastPlayTime.key, 13);
|
|
|
ofile.write((char*)&shortcut.LastPlayTime.value, 4);
|
|
|
|
|
|
//
|
|
|
ofile.write((char*)&shortcut.tags.type_id, 1);
|
|
|
ofile.write(shortcut.tags.key, 5);
|
|
|
for (auto& tag : shortcut.tags.value) {
|
|
|
ofile.write(tag.idx.data, 2);
|
|
|
ofile.write("\x00", 1);
|
|
|
ofile.write(tag.value.data(), tag.value.length());
|
|
|
ofile.write("\x00", 1);
|
|
|
}
|
|
|
ofile.write("\x08\x08", 2);
|
|
|
}
|
|
|
ofile.write("\x08\x08", 2);
|
|
|
ofile.close();
|
|
|
return true;
|
|
|
}
|
|
|
};
|
|
|
} // namespace VDFParser
|