return date

? ('@' + QString::fromUtf8(FormatDateTime(date, 0, '-', '-', '_')))

: QString();

return "photo_"

+ QString::number(index)

+ PrepareFileNameDatePart(date)

+ ".jpg";

int index,

TimeId date,

const Utf8String &extension) {

return "story_"

+ QString::number(index)

+ PrepareFileNameDatePart(date)

+ extension;

const MTPDreplyInlineMarkup &data) {

const auto &list = data.vrows().v;

if (list.isEmpty()) {

return {};

}

using Type = HistoryMessageMarkupButton::Type;

auto rows = std::vector<std::vector<HistoryMessageMarkupButton>>();

rows.reserve(list.size());

for (const auto &tlRow : list) {

auto row = std::vector<HistoryMessageMarkupButton>();

row.reserve(tlRow.data().vbuttons().v.size());

for (const auto &button : tlRow.data().vbuttons().v) {

const auto &fields = button.data();

const auto text = qs(fields.vtext());

fields.vtype().match([&](const MTPDinlineButtonTypeUrl &data) {

row.push_back({

Type::Url,

text,

qba(data.vurl())

});

}, [&](const MTPDinlineButtonTypeUrlAuth &data) {

row.push_back({

Type::Auth,

text,

qba(data.vurl()),

qs(data.vfwd_text().value_or_empty()),

data.vbutton_id().v,

});

}, [&](const MTPDinputInlineButtonTypeUrlAuth &) {

}, [&](const MTPDinlineButtonTypeWebView &data) {

row.push_back({

Type::WebView,

text,

data.vurl().v

});

}, [&](const MTPDinlineButtonTypeCallback &data) {

row.push_back({

(data.is_requires_password()

? Type::CallbackWithPassword

: Type::Callback),

text,

qba(data.vdata())

});

}, [&](const MTPDinlineButtonTypeGame &) {

row.push_back({ Type::Game, text });

}, [&](const MTPDinlineButtonTypeBuy &) {

row.push_back({ Type::Buy, text });

}, [&](const MTPDinlineButtonTypeSwitchInline &data) {

const auto type = data.is_same_peer()

? Type::SwitchInlineSame

: Type::SwitchInline;

row.push_back({ type, text, qba(data.vquery()) });

}, [&](const MTPDinlineButtonTypeUserProfile &data) {

row.push_back({

Type::UserProfile,

text,

QByteArray::number(data.vuser_id().v)

});

}, [&](const MTPDinputInlineButtonTypeUserProfile &) {

}, [&](const MTPDinlineButtonTypeCopy &data) {

row.push_back({

Type::CopyText,

text,

data.vcopy_text().v,

});

}, [&](const MTPDinlineButtonTypeDisabled &) {

row.push_back({ Type::Disabled, text });

});

}

if (!row.empty()) {

rows.push_back(std::move(row));

}

}

return rows;

const InlineButtonAction &action) {

using Type = InlineButtonAction::Type;

switch (action.type) {

case Type::Url: return "url";

case Type::Auth: return "auth";

case Type::WebView: return "web_view";

case Type::Callback: return "callback";

case Type::CallbackWithPassword: return "callback_with_password";

case Type::Game: return "game";

case Type::Buy: return "buy";

case Type::SwitchInline: return "switch_inline";

case Type::SwitchInlineSame: return "switch_inline_same";

case Type::UserProfile: return "user_profile";

case Type::CopyText: return "copy_text";

case Type::Disabled: return "disabled";

}

Unexpected("Type in InlineButtonAction::Type.");

using Type = InlineButtonPeerType;

switch (type) {

case Type::SameBotPM: return "same_bot_pm";

case Type::PM: return "pm";

case Type::Chat: return "chat";

case Type::Megagroup: return "megagroup";

case Type::Broadcast: return "broadcast";

case Type::BotPM: return "bot_pm";

}

Unexpected("Type in InlineButtonPeerType.");

using Style = RichButtonStyle;

switch (style) {

case Style::Default: return "default";

case Style::Primary: return "primary";

case Style::Success: return "success";

case Style::Danger: return "danger";

case Style::Link: return "link";

}

Unexpected("Style in RichButtonStyle.");

using Alignment = RichButtonAlignment;

switch (alignment) {

case Alignment::Stretch: return "stretch";

case Alignment::Left: return "left";

case Alignment::Center: return "center";

case Alignment::Right: return "right";

}

Unexpected("Alignment in RichButtonAlignment.");

const HistoryMessageMarkupButton &button) {

using Type = HistoryMessageMarkupButton::Type;

switch (button.type) {

case Type::Default: return "default";

case Type::Url: return "url";

case Type::Callback: return "callback";

case Type::CallbackWithPassword: return "callback_with_password";

case Type::RequestPhone: return "request_phone";

case Type::RequestLocation: return "request_location";

case Type::RequestPoll: return "request_poll";

case Type::RequestPeer: return "request_peer";

case Type::SwitchInline: return "switch_inline";

case Type::SwitchInlineSame: return "switch_inline_same";

case Type::Game: return "game";

case Type::Buy: return "buy";

case Type::Auth: return "auth";

case Type::UserProfile: return "user_profile";

case Type::WebView: return "web_view";

case Type::SimpleWebView: return "simple_web_view";

case Type::CopyText: return "copy_text";

case Type::Disabled: return "disabled";

}

Unexpected("Type in HistoryMessageMarkupButton::Type.");

auto result = BareId(0xFF);

for (const auto ch : data) {

result *= 239;

result += ch;

result &= 0xFF;

}

return result;

static const auto official = std::map<int, int> {

{ 1, 0 }, // iOS

{ 7, 0 }, // iOS X

{ 6, 1 }, // Android

{ 21724, 1 }, // Android X

{ 2834, 2 }, // macOS

{ 2496, 3 }, // Webogram

{ 2040, 4 }, // Desktop

{ 1429, 5 }, // Windows Phone

};

if (const auto i = official.find(applicationId); i != end(official)) {

return i->second;

}

return PeerColorIndex(applicationId);

const MTPstring &data,

const QVector<MTPMessageEntity> &entities) {

using Type = TextPart::Type;

const auto text = QString::fromUtf8(data.v);

const auto size = data.v.size();

const auto mid = [&](int offset, int length) {

return text.mid(offset, length).toUtf8();

};

auto result = std::vector<TextPart>();

auto offset = 0;

auto addTextPart = [&](int till) {

if (till > offset) {

auto part = TextPart();

part.text = mid(offset, till - offset);

result.push_back(std::move(part));

offset = till;

}

};

for (const auto &entity : entities) {

const auto start = entity.match([](const auto &data) {

return data.voffset().v;

});

const auto length = entity.match([](const auto &data) {

return data.vlength().v;

});

if (start < offset || length <= 0 || start + length > size) {

continue;

}

addTextPart(start);

auto part = TextPart();

part.type = entity.match(

[](const MTPDmessageEntityUnknown&) { return Type::Unknown; },

[](const MTPDmessageEntityMention&) { return Type::Mention; },

[](const MTPDmessageEntityHashtag&) { return Type::Hashtag; },

[](const MTPDmessageEntityBotCommand&) {

return Type::BotCommand; },

[](const MTPDmessageEntityUrl&) { return Type::Url; },

[](const MTPDmessageEntityEmail&) { return Type::Email; },

[](const MTPDmessageEntityBold&) { return Type::Bold; },

[](const MTPDmessageEntityItalic&) { return Type::Italic; },

[](const MTPDmessageEntityCode&) { return Type::Code; },

[](const MTPDmessageEntityPre&) { return Type::Pre; },

[](const MTPDmessageEntityTextUrl&) { return Type::TextUrl; },

[](const MTPDmessageEntityMentionName&) {

return Type::MentionName; },

[](const MTPDinputMessageEntityMentionName&) {

return Type::MentionName; },

[](const MTPDmessageEntityPhone&) { return Type::Phone; },

[](const MTPDmessageEntityCashtag&) { return Type::Cashtag; },

[](const MTPDmessageEntityUnderline&) { return Type::Underline; },

[](const MTPDmessageEntityStrike&) { return Type::Strike; },

[](const MTPDmessageEntityBlockquote&) {

return Type::Blockquote; },

[](const MTPDmessageEntityBankCard&) { return Type::BankCard; },

[](const MTPDmessageEntitySpoiler&) { return Type::Spoiler; },

[](const MTPDmessageEntityCustomEmoji&) { return Type::CustomEmoji; },

[](const MTPDmessageEntityFormattedDate&) { return Type::Unknown; },

[](const MTPDmessageEntityDiffInsert&) { return Type::Unknown; },

[](const MTPDmessageEntityDiffReplace&) { return Type::Unknown; },

[](const MTPDmessageEntityDiffDelete&) { return Type::Unknown; });

part.text = mid(start, length);

part.additional = entity.match(

[](const MTPDmessageEntityPre &data) {

return ParseString(data.vlanguage());

}, [](const MTPDmessageEntityTextUrl &data) {

return ParseString(data.vurl());

}, [](const MTPDmessageEntityMentionName &data) {

return NumberToString(data.vuser_id().v);

}, [](const MTPDmessageEntityCustomEmoji &data) {

return NumberToString(data.vdocument_id().v);

}, [](const MTPDmessageEntityBlockquote &data) {

return data.is_collapsed() ? Utf8String("1") : Utf8String();

}, [](const auto &) { return Utf8String(); });

result.push_back(std::move(part));

offset = start + length;

}

addTextPart(size);

return result;

switch (reaction.type) {

case Reaction::Type::Empty: return "empty";

case Reaction::Type::Emoji: return "emoji";

case Reaction::Type::CustomEmoji: return "custom_emoji";

case Reaction::Type::Paid: return "paid";

}

Unexpected("Type in Reaction::Type.");

const MTPInlineQueryPeerType &type) {

using Type = InlineButtonPeerType;

return type.match(

[](const MTPDinlineQueryPeerTypeSameBotPM &) {

return Type::SameBotPM;

}, [](const MTPDinlineQueryPeerTypePM &) {

return Type::PM;

}, [](const MTPDinlineQueryPeerTypeChat &) {

return Type::Chat;

}, [](const MTPDinlineQueryPeerTypeMegagroup &) {

return Type::Megagroup;

}, [](const MTPDinlineQueryPeerTypeBroadcast &) {

return Type::Broadcast;

}, [](const MTPDinlineQueryPeerTypeBotPM &) {

return Type::BotPM;

});

const MTPInlineButtonType &type) {

using Type = InlineButtonAction::Type;

auto result = std::optional<InlineButtonAction>();

type.match([&](const MTPDinlineButtonTypeUrl &data) {

auto &action = result.emplace();

action.type = Type::Url;

action.url = ParseString(data.vurl());

}, [&](const MTPDinlineButtonTypeUrlAuth &data) {

auto &action = result.emplace();

action.type = Type::Auth;

action.url = ParseString(data.vurl());

action.buttonId = data.vbutton_id().v;

if (const auto forwardText = data.vfwd_text()) {

action.forwardText = ParseString(*forwardText);

}

}, [&](const MTPDinputInlineButtonTypeUrlAuth &) {

}, [&](const MTPDinlineButtonTypeWebView &data) {

auto &action = result.emplace();

action.type = Type::WebView;

action.url = ParseString(data.vurl());

}, [&](const MTPDinlineButtonTypeCallback &data) {

auto &action = result.emplace();

action.requiresPassword = data.is_requires_password();

action.type = action.requiresPassword

? Type::CallbackWithPassword

: Type::Callback;

action.callbackData = qba(data.vdata());

}, [&](const MTPDinlineButtonTypeGame &) {

auto &action = result.emplace();

action.type = Type::Game;

}, [&](const MTPDinlineButtonTypeBuy &) {

auto &action = result.emplace();

action.type = Type::Buy;

}, [&](const MTPDinlineButtonTypeSwitchInline &data) {

auto &action = result.emplace();

action.samePeer = data.is_same_peer();

action.type = action.samePeer

? Type::SwitchInlineSame

: Type::SwitchInline;

action.query = ParseString(data.vquery());

if (const auto peerTypes = data.vpeer_types()) {

auto &parsed = action.peerTypes.emplace();

parsed.reserve(peerTypes->v.size());

for (const auto &peerType : peerTypes->v) {

parsed.push_back(ParseInlineButtonPeerType(peerType));

}

}

}, [&](const MTPDinlineButtonTypeUserProfile &data) {

auto &action = result.emplace();

action.type = Type::UserProfile;

action.userId = uint64(data.vuser_id().v);

}, [&](const MTPDinputInlineButtonTypeUserProfile &) {

}, [&](const MTPDinlineButtonTypeCopy &data) {

auto &action = result.emplace();

action.type = Type::CopyText;

action.copyText = ParseString(data.vcopy_text());

}, [&](const MTPDinlineButtonTypeDisabled &) {

auto &action = result.emplace();

action.type = Type::Disabled;

});

return result;

using Type = InlineButtonAction::Type;

return (type == Type::Callback)

|| (type == Type::CallbackWithPassword)

|| (type == Type::Disabled);

const tl::conditional<MTPRichButtonStyle> &style,

InlineButtonAction::Type actionType,

bool inlineButton) {

if (!style) {

return std::nullopt;

}

const auto &data = style->data();

if (inlineButton

&& data.is_link()

&& RichButtonLinkStyleAllowed(actionType)) {

return RichButtonStyle::Link;

}

return data.is_bg_danger()

? RichButtonStyle::Danger

: data.is_bg_primary()

? RichButtonStyle::Primary

: data.is_bg_success()

? RichButtonStyle::Success

: RichButtonStyle::Default;

const MTPRichText &text,

const MTPInlineButtonType &type,

const tl::conditional<MTPRichButtonStyle> &style,

bool inlineButton) {

auto action = ParseInlineButtonAction(type);

if (!action) {

return std::nullopt;

}

auto result = RichText();

result.type = RichText::Type::Button;

result.children.reserve(1);

result.children.push_back(ParseRichText(text));

auto buttonStyle = ParseRichButtonStyle(

style,

action->type,

inlineButton);

result.button = std::make_unique<RichButtonPayload>(RichButtonPayload{

.action = std::move(*action),

.style = std::move(buttonStyle),

});

return result;

RichText::Type type,

const MTPRichText &child) {

auto result = RichText();

result.type = type;

result.children.reserve(1);

result.children.push_back(ParseRichText(child));

return result;

using Type = RichText::Type;

return text.match(

[](const MTPDtextEmpty &) {

auto result = RichText();

result.type = Type::Empty;

return result;

}, [](const MTPDtextPlain &data) {

auto result = RichText();

result.type = Type::Plain;

result.text = ParseString(data.vtext());

return result;

}, [](const MTPDtextBold &data) {

return ParseRichTextWrapper(Type::Bold, data.vtext());

}, [](const MTPDtextItalic &data) {

return ParseRichTextWrapper(Type::Italic, data.vtext());

}, [](const MTPDtextUnderline &data) {

return ParseRichTextWrapper(Type::Underline, data.vtext());

}, [](const MTPDtextStrike &data) {

return ParseRichTextWrapper(Type::Strike, data.vtext());

}, [](const MTPDtextFixed &data) {

return ParseRichTextWrapper(Type::Fixed, data.vtext());

}, [](const MTPDtextUrl &data) {

auto result = ParseRichTextWrapper(Type::Url, data.vtext());

result.data = ParseString(data.vurl());

result.id = uint64(data.vwebpage_id().v);

return result;

}, [](const MTPDtextEmail &data) {

auto result = ParseRichTextWrapper(Type::Email, data.vtext());

result.data = ParseString(data.vemail());

return result;

}, [](const MTPDtextConcat &data) {

auto result = RichText();

result.type = Type::Concat;

const auto &texts = data.vtexts().v;

result.children.reserve(texts.size());

for (const auto &text : texts) {

result.children.push_back(ParseRichText(text));

}

return result;

}, [](const MTPDtextSubscript &data) {

return ParseRichTextWrapper(Type::Subscript, data.vtext());

}, [](const MTPDtextSuperscript &data) {

return ParseRichTextWrapper(Type::Superscript, data.vtext());

}, [](const MTPDtextMarked &data) {

return ParseRichTextWrapper(Type::Marked, data.vtext());

}, [](const MTPDtextPhone &data) {

auto result = ParseRichTextWrapper(Type::Phone, data.vtext());

result.data = ParseString(data.vphone());

return result;

}, [](const MTPDtextImage &data) {

auto result = RichText();

result.type = Type::InlineImage;

result.id = uint64(data.vdocument_id().v);

result.width = data.vw().v;

result.height = data.vh().v;

return result;

}, [](const MTPDtextAnchor &data) {

auto result = ParseRichTextWrapper(Type::Anchor, data.vtext());

result.data = ParseString(data.vname());

return result;

}, [](const MTPDtextMath &data) {

auto result = RichText();

result.type = Type::Math;

result.data = ParseString(data.vsource());

return result;

}, [](const MTPDtextCustomEmoji &data) {

auto result = RichText();

result.type = Type::CustomEmoji;

result.text = ParseString(data.valt());

result.id = uint64(data.vdocument_id().v);

result.customEmojiData = NumberToString(result.id);

return result;

}, [](const MTPDtextSpoiler &data) {

return ParseRichTextWrapper(Type::Spoiler, data.vtext());

}, [](const MTPDtextMention &data) {

return ParseRichTextWrapper(Type::Mention, data.vtext());

}, [](const MTPDtextHashtag &data) {

return ParseRichTextWrapper(Type::Hashtag, data.vtext());

}, [](const MTPDtextBotCommand &data) {

return ParseRichTextWrapper(Type::BotCommand, data.vtext());

}, [](const MTPDtextCashtag &data) {

return ParseRichTextWrapper(Type::Cashtag, data.vtext());

}, [](const MTPDtextAutoUrl &data) {

return ParseRichTextWrapper(Type::AutoUrl, data.vtext());

}, [](const MTPDtextAutoEmail &data) {

return ParseRichTextWrapper(Type::AutoEmail, data.vtext());

}, [](const MTPDtextAutoPhone &data) {

return ParseRichTextWrapper(Type::AutoPhone, data.vtext());

}, [](const MTPDtextBankCard &data) {

return ParseRichTextWrapper(Type::BankCard, data.vtext());

}, [](const MTPDtextMentionName &data) {

auto result = ParseRichTextWrapper(Type::MentionName, data.vtext());

result.id = uint64(data.vuser_id().v);

return result;

}, [](const MTPDtextDate &data) {

auto result = ParseRichTextWrapper(Type::FormattedDate, data.vtext());

result.date = data.vdate().v;

result.relative = data.is_relative();

result.shortTime = data.is_short_time();

result.longTime = data.is_long_time();

result.shortDate = data.is_short_date();

result.longDate = data.is_long_date();

result.dayOfWeek = data.is_day_of_week();

return result;

}, [](const MTPDtextDiff &data) {

auto result = RichText();

result.type = Type::Diff;

result.unsupported = true;

result.children.reserve(1);

result.children.push_back(ParseRichText(data.vtext()));

result.oldChildren.reserve(1);

result.oldChildren.push_back(ParseRichText(data.vold_text()));

return result;

}, [](const MTPDtextButton &data) {

if (auto button = ParseRichButton(

data.vtext(),

data.vtype(),

data.vstyle(),

true)) {

return std::move(*button);

}

return ParseRichText(data.vtext());

});

const auto &data = caption.data();

return {

.text = ParseRichText(data.vtext()),

.credit = ParseRichText(data.vcredit()),

};

if (!checkbox) {

return RichTaskState::None;

}

return checked ? RichTaskState::Checked : RichTaskState::Unchecked;

return item.match([](const MTPDpageListItemText &data) {

auto result = RichListItem();

result.content = RichListItemContent::Text;

result.taskState = ParseRichTaskState(

data.is_checkbox(),

data.is_checked());

result.text = ParseRichText(data.vtext());

return result;

}, [](const MTPDpageListItemBlocks &data) {

auto result = RichListItem();

result.content = RichListItemContent::Blocks;

result.taskState = ParseRichTaskState(

data.is_checkbox(),

data.is_checked());

result.blocks = ParseRichBlocks(data.vblocks().v);

return result;

});

RichListItem &result,

const Data &data) {

result.taskState = ParseRichTaskState(

data.is_checkbox(),

data.is_checked());

if (const auto num = data.vnum()) {

result.num = ParseString(*num);

}

if (const auto value = data.vvalue()) {

result.value = value->v;

}

if (const auto type = data.vtype()) {

result.type = ParseString(*type);

}

const MTPPageListOrderedItem &item) {

return item.match([](const MTPDpageListOrderedItemText &data) {

auto result = RichListItem();

result.content = RichListItemContent::Text;

FillRichOrderedListItem(result, data);

result.text = ParseRichText(data.vtext());

return result;

}, [](const MTPDpageListOrderedItemBlocks &data) {

auto result = RichListItem();

result.content = RichListItemContent::Blocks;

FillRichOrderedListItem(result, data);

result.blocks = ParseRichBlocks(data.vblocks().v);

return result;

});

const MTPDpageTableCell &data) {

if (data.is_align_right()) {

return RichTableAlignment::Right;

} else if (data.is_align_center()) {

return RichTableAlignment::Center;

}

return RichTableAlignment::Left;

const MTPDpageTableCell &data) {

if (data.is_valign_bottom()) {

return RichTableVerticalAlignment::Bottom;

} else if (data.is_valign_middle()) {

return RichTableVerticalAlignment::Middle;

}

return RichTableVerticalAlignment::Top;

const auto &data = cell.data();

auto result = RichTableCell();

result.header = data.is_header();

result.alignment = ParseRichTableAlignment(data);

result.verticalAlignment = ParseRichTableVerticalAlignment(data);

if (const auto text = data.vtext()) {

result.text = ParseRichText(*text);

}

if (const auto colspan = data.vcolspan()) {

result.colspan = colspan->v;

}

if (const auto rowspan = data.vrowspan()) {

result.rowspan = rowspan->v;

}

return result;

const auto &cells = row.data().vcells().v;

auto result = RichTableRow();

result.cells.reserve(cells.size());

for (const auto &cell : cells) {

result.cells.push_back(ParseRichTableCell(cell));

}

return result;

const MTPPageRelatedArticle &article) {

const auto &data = article.data();

auto result = RichRelatedArticle();

result.url = ParseString(data.vurl());

result.webpageId = uint64(data.vwebpage_id().v);

if (const auto title = data.vtitle()) {

result.title = ParseString(*title);

}

if (const auto description = data.vdescription()) {

result.description = ParseString(*description);

}

if (const auto photoId = data.vphoto_id()) {

result.photoId = uint64(photoId->v);

}

if (const auto author = data.vauthor()) {

result.author = ParseString(*author);

}

if (const auto publishedDate = data.vpublished_date()) {

result.publishedDate = publishedDate->v;

}

return result;

using Source = RichChannel::Source;

return chat.match([](const MTPDchatEmpty &data) {

auto result = RichChannel();

result.source = Source::ChatEmpty;

result.id = uint64(data.vid().v);

return result;

}, [](const MTPDchat &data) {

auto result = RichChannel();

result.source = Source::Chat;

result.id = uint64(data.vid().v);

result.title = ParseString(data.vtitle());

return result;

}, [](const MTPDchatForbidden &data) {

auto result = RichChannel();

result.source = Source::ChatForbidden;

result.id = uint64(data.vid().v);

result.title = ParseString(data.vtitle());

return result;

}, [](const MTPDchannel &data) {

auto result = RichChannel();

result.source = Source::Channel;

result.id = uint64(data.vid().v);

result.title = ParseString(data.vtitle());

result.broadcast = data.is_broadcast();

result.megagroup = data.is_megagroup();

result.monoforum = data.is_monoforum();

if (const auto accessHash = data.vaccess_hash()) {

result.accessHash = int64(accessHash->v);

}

if (const auto username = data.vusername()) {

result.username = ParseString(*username);

}

return result;

}, [](const MTPDchannelForbidden &data) {

auto result = RichChannel();

result.source = Source::ChannelForbidden;

result.id = uint64(data.vid().v);

result.title = ParseString(data.vtitle());

result.accessHash = int64(data.vaccess_hash().v);

result.broadcast = data.is_broadcast();

result.megagroup = data.is_megagroup();

result.monoforum = data.is_monoforum();

return result;

}, [](const MTPDcommunity &data) {

auto result = RichChannel();

result.source = Source::Community;

result.id = uint64(data.vid().v);

result.title = ParseString(data.vtitle());

if (const auto accessHash = data.vaccess_hash()) {

result.accessHash = int64(accessHash->v);

}

return result;

}, [](const MTPDcommunityForbidden &data) {

auto result = RichChannel();

result.source = Source::CommunityForbidden;

result.id = uint64(data.vid().v);

result.title = ParseString(data.vtitle());

if (const auto accessHash = data.vaccess_hash()) {

result.accessHash = int64(accessHash->v);

}

return result;

});

using Source = RichMapPoint::Source;

return point.match([](const MTPDgeoPointEmpty &) {

auto result = RichMapPoint();

result.source = Source::GeoPointEmpty;

return result;

}, [](const MTPDgeoPoint &data) {

auto result = RichMapPoint();

result.source = Source::GeoPoint;

result.latitude = data.vlat().v;

result.longitude = data.vlong().v;

result.accessHash = int64(data.vaccess_hash().v);

if (const auto accuracyRadius = data.vaccuracy_radius()) {

result.accuracyRadius = accuracyRadius->v;

}

return result;

});

using Source = RichMapPoint::Source;

return point.match([](const MTPDinputGeoPointEmpty &) {

auto result = RichMapPoint();

result.source = Source::InputGeoPointEmpty;

return result;

}, [](const MTPDinputGeoPoint &data) {

auto result = RichMapPoint();

result.source = Source::InputGeoPoint;

result.latitude = data.vlat().v;

result.longitude = data.vlong().v;

if (const auto accuracyRadius = data.vaccuracy_radius()) {

result.accuracyRadius = accuracyRadius->v;

}

return result;

});

auto result = RichBlock();

result.kind = kind;

return result;

RichBlock::Kind kind,

const MTPRichText &text) {

auto result = RichBlock();

result.kind = kind;

result.text = ParseRichText(text);

return result;

int level,

const MTPRichText &text) {

auto result = ParseRichTextBlock(RichBlock::Kind::Heading, text);

result.headingLevel = level;

return result;

auto result = ParseRichSupportedBlock(kind);

result.unsupported = true;

return result;

using Kind = RichBlock::Kind;

return block.match(

[](const MTPDpageBlockUnsupported &) {

return ParseRichUnsupportedBlock(Kind::Unsupported);

}, [](const MTPDpageBlockTitle &data) {

return ParseRichHeadingBlock(1, data.vtext());

}, [](const MTPDpageBlockSubtitle &data) {

return ParseRichHeadingBlock(2, data.vtext());

}, [](const MTPDpageBlockAuthorDate &data) {

auto result = ParseRichTextBlock(Kind::AuthorDate, data.vauthor());

result.date = data.vpublished_date().v;

return result;

}, [](const MTPDpageBlockHeader &data) {

return ParseRichHeadingBlock(3, data.vtext());

}, [](const MTPDpageBlockSubheader &data) {

return ParseRichHeadingBlock(4, data.vtext());

}, [](const MTPDpageBlockParagraph &data) {

return ParseRichTextBlock(Kind::Paragraph, data.vtext());

}, [](const MTPDpageBlockPreformatted &data) {

auto result = ParseRichTextBlock(Kind::Code, data.vtext());

result.language = ParseString(data.vlanguage());

return result;

}, [](const MTPDpageBlockFooter &data) {

return ParseRichTextBlock(Kind::Footer, data.vtext());

}, [](const MTPDpageBlockDivider &) {

auto result = RichBlock();

result.kind = Kind::Divider;

return result;

}, [](const MTPDpageBlockAnchor &data) {

auto result = RichBlock();

result.kind = Kind::Anchor;

result.name = ParseString(data.vname());

return result;

}, [](const MTPDpageBlockList &data) {

auto result = RichBlock();

result.kind = Kind::List;

result.listKind = RichListKind::Bullet;

const auto &items = data.vitems().v;

result.listItems.reserve(items.size());

for (const auto &item : items) {

result.listItems.push_back(ParseRichListItem(item));

}

return result;

}, [](const MTPDpageBlockBlockquote &data) {

auto result = ParseRichTextBlock(Kind::Quote, data.vtext());

result.quoteContent = RichQuoteContent::Text;

result.quoteCaption = ParseRichText(data.vcaption());

return result;

}, [](const MTPDpageBlockPullquote &data) {

auto result = ParseRichTextBlock(Kind::Quote, data.vtext());

result.quoteContent = RichQuoteContent::Text;

result.quoteCaption = ParseRichText(data.vcaption());

result.pullquote = true;

return result;

}, [](const MTPDpageBlockPhoto &data) {

auto result = ParseRichSupportedBlock(Kind::Photo);

result.photoId = uint64(data.vphoto_id().v);

result.caption = ParseRichCaption(data.vcaption());

result.spoiler = data.is_spoiler();

if (const auto url = data.vurl()) {

result.optionalUrl = ParseString(*url);

}

if (const auto webpageId = data.vwebpage_id()) {

result.optionalWebpageId = uint64(webpageId->v);

}

return result;

}, [](const MTPDpageBlockVideo &data) {

auto result = ParseRichSupportedBlock(Kind::Video);

result.documentId = uint64(data.vvideo_id().v);

result.caption = ParseRichCaption(data.vcaption());

result.autoplay = data.is_autoplay();

result.loop = data.is_loop();

result.spoiler = data.is_spoiler();

return result;

}, [](const MTPDpageBlockCover &data) {

auto result = ParseRichSupportedBlock(Kind::Cover);