RepoMirrors/tdesktop
1
0
Fork 0
mirror of https://github.com/telegramdesktop/tdesktop synced 2025-04-01 23:00:58 +00:00
Code Issues Projects Releases Wiki Activity

Made base::lambda a copyable value type.

Browse Source 
Now base::lambda can be copied and can wrap any immutable lambda.
For mutable lambdas there is base::lambda_once (which you're
supposed to call only once to pass data through lambda captures,
for example by using std::unique_ptr). Generally base::lambda is
passed by value and base::lambda_once is passed by rvalue reference.
This commit is contained in:
John Preston 2017-02-26 14:32:13 +03:00
parent f82989c9c3
commit c207743338
78 changed files with 662 additions and 633 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Telegram/SourceFiles/apiwrap.cpp
View File

@ -44,7 +44,7 @@ ApiWrap::ApiWrap(QObject *parent) : QObject(parent)
void ApiWrap::init() {
}
void ApiWrap::requestMessageData(ChannelData *channel, MsgId msgId, const RequestMessageDataCallback &callback) {
void ApiWrap::requestMessageData(ChannelData *channel, MsgId msgId, RequestMessageDataCallback callback) {
MessageDataRequest &req(channel ? _channelMessageDataRequests[channel][msgId] : _messageDataRequests[msgId]);
if (callback) {
req.callbacks.append(callback);

4
Telegram/SourceFiles/apiwrap.h
View File

@ -41,8 +41,8 @@ public:
ApiWrap(QObject *parent);
void init();
using RequestMessageDataCallback = base::lambda_copy<void(ChannelData*, MsgId)>;
void requestMessageData(ChannelData *channel, MsgId msgId, const RequestMessageDataCallback &callback);
using RequestMessageDataCallback = base::lambda<void(ChannelData*, MsgId)>;
void requestMessageData(ChannelData *channel, MsgId msgId, RequestMessageDataCallback callback);
void requestFullPeer(PeerData *peer);
void requestPeer(PeerData *peer);

8
Telegram/SourceFiles/boxes/abstractbox.cpp
View File

@ -33,11 +33,11 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
BoxLayerTitleShadow::BoxLayerTitleShadow(QWidget *parent) : Ui::PlainShadow(parent, st::boxLayerTitleShadow) {
}
QPointer<Ui::RoundButton> BoxContent::addButton(const QString &text, base::lambda<void()> &&clickCallback) {
QPointer<Ui::RoundButton> BoxContent::addButton(const QString &text, base::lambda<void()> clickCallback) {
return addButton(text, std::move(clickCallback), st::defaultBoxButton);
}
QPointer<Ui::RoundButton> BoxContent::addLeftButton(const QString &text, base::lambda<void()> &&clickCallback) {
QPointer<Ui::RoundButton> BoxContent::addLeftButton(const QString &text, base::lambda<void()> clickCallback) {
return getDelegate()->addLeftButton(text, std::move(clickCallback), st::defaultBoxButton);
}
@ -310,7 +310,7 @@ void AbstractBox::clearButtons() {
_leftButton.destroy();
}
QPointer<Ui::RoundButton> AbstractBox::addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) {
QPointer<Ui::RoundButton> AbstractBox::addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) {
_buttons.push_back(object_ptr<Ui::RoundButton>(this, text, st));
auto result = QPointer<Ui::RoundButton>(_buttons.back());
result->setClickedCallback(std::move(clickCallback));
@ -319,7 +319,7 @@ QPointer<Ui::RoundButton> AbstractBox::addButton(const QString &text, base::lamb
return result;
}
QPointer<Ui::RoundButton> AbstractBox::addLeftButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) {
QPointer<Ui::RoundButton> AbstractBox::addLeftButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) {
_leftButton = object_ptr<Ui::RoundButton>(this, text, st);
auto result = QPointer<Ui::RoundButton>(_leftButton);
result->setClickedCallback(std::move(clickCallback));

14
Telegram/SourceFiles/boxes/abstractbox.h
View File

@ -43,8 +43,8 @@ public:
virtual void setTitle(const QString &title, const QString &additional) = 0;
virtual void clearButtons() = 0;
virtual QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) = 0;
virtual QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) = 0;
virtual QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) = 0;
virtual QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) = 0;
virtual void updateButtonsPositions() = 0;
virtual void setDimensions(int newWidth, int maxHeight) = 0;
@ -98,9 +98,9 @@ protected:
void clearButtons() {
getDelegate()->clearButtons();
}
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback);
QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> &&clickCallback);
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) {
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback);
QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> clickCallback);
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) {
return getDelegate()->addButton(text, std::move(clickCallback), st);
}
void updateButtonsGeometry() {
@ -187,8 +187,8 @@ public:
void setTitle(const QString &title, const QString &additional) override;
void clearButtons() override;
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) override;
QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) override;
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) override;
QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) override;
void updateButtonsPositions() override;
void setDimensions(int newWidth, int maxHeight) override;

2
Telegram/SourceFiles/boxes/addcontactbox.cpp
View File

@ -1111,7 +1111,7 @@ void EditChannelBox::onSaveSignDone(const MTPUpdates &updates) {
closeBox();
}
RevokePublicLinkBox::RevokePublicLinkBox(QWidget*, base::lambda<void()> &&revokeCallback)
RevokePublicLinkBox::RevokePublicLinkBox(QWidget*, base::lambda<void()> revokeCallback)
: _rowHeight(st::contactsPadding.top() + st::contactsPhotoSize + st::contactsPadding.bottom())
, _revokeWidth(st::normalFont->width(lang(lng_channels_too_much_public_revoke)))
, _aboutRevoke(this, lang(lng_channels_too_much_public_about), Ui::FlatLabel::InitType::Simple, st::aboutRevokePublicLabel)

2
Telegram/SourceFiles/boxes/addcontactbox.h
View File

@ -278,7 +278,7 @@ private:
class RevokePublicLinkBox : public BoxContent, public RPCSender {
public:
RevokePublicLinkBox(QWidget*, base::lambda<void()> &&revokeCallback);
RevokePublicLinkBox(QWidget*, base::lambda<void()> revokeCallback);
protected:
void prepare() override;

2
Telegram/SourceFiles/boxes/backgroundbox.h
View File

@ -46,7 +46,7 @@ class BackgroundBox::Inner : public TWidget, public RPCSender, private base::Sub
public:
Inner(QWidget *parent);
void setBackgroundChosenCallback(base::lambda<void(int index)> &&callback) {
void setBackgroundChosenCallback(base::lambda<void(int index)> callback) {
_backgroundChosenCallback = std::move(callback);
}

18
Telegram/SourceFiles/boxes/confirmbox.cpp
View File

@ -41,7 +41,7 @@ TextParseOptions _confirmBoxTextOptions = {
Qt::LayoutDirectionAuto, // dir
};
ConfirmBox::ConfirmBox(QWidget*, const QString &text, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback)
ConfirmBox::ConfirmBox(QWidget*, const QString &text, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(lang(lng_box_ok))
, _cancelText(lang(lng_cancel))
, _confirmStyle(st::defaultBoxButton)
@ -51,7 +51,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, base::lambda<void()> &&con
init(text);
}
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback)
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText)
, _cancelText(lang(lng_cancel))
, _confirmStyle(st::defaultBoxButton)
@ -61,7 +61,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text);
}
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback)
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText)
, _cancelText(lang(lng_cancel))
, _confirmStyle(confirmStyle)
@ -71,7 +71,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text);
}
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback)
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText)
, _cancelText(cancelText)
, _confirmStyle(st::defaultBoxButton)
@ -81,7 +81,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text);
}
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback)
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText)
, _cancelText(cancelText)
, _confirmStyle(st::defaultBoxButton)
@ -91,7 +91,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text);
}
ConfirmBox::ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback)
ConfirmBox::ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda<void()> closedCallback)
: _confirmText(doneText)
, _confirmStyle(st::defaultBoxButton)
, _informative(true)
@ -101,7 +101,7 @@ ConfirmBox::ConfirmBox(const InformBoxTag &, const QString &text, const QString
init(text);
}
base::lambda<void()> ConfirmBox::generateInformCallback(const base::lambda_copy<void()> &closedCallback) {
base::lambda<void()> ConfirmBox::generateInformCallback(base::lambda<void()> closedCallback) {
auto callback = closedCallback;
return base::lambda_guarded(this, [this, callback] {
closeBox();
@ -212,10 +212,10 @@ void ConfirmBox::paintEvent(QPaintEvent *e) {
_text.drawLeftElided(p, st::boxPadding.left(), st::boxPadding.top(), _textWidth, width(), 16, style::al_left);
}
InformBox::InformBox(QWidget*, const QString &text, base::lambda_copy<void()> &&closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, lang(lng_box_ok), std::move(closedCallback)) {
InformBox::InformBox(QWidget*, const QString &text, base::lambda<void()> closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, lang(lng_box_ok), std::move(closedCallback)) {
}
InformBox::InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, doneText, std::move(closedCallback)) {
InformBox::InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda<void()> closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, doneText, std::move(closedCallback)) {
}
MaxInviteBox::MaxInviteBox(QWidget*, const QString &link)

18
Telegram/SourceFiles/boxes/confirmbox.h
View File

@ -30,11 +30,11 @@ class FlatLabel;
class InformBox;
class ConfirmBox : public BoxContent, public ClickHandlerHost {
public:
ConfirmBox(QWidget*, const QString &text, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
void updateLink();
@ -62,8 +62,8 @@ protected:
private:
struct InformBoxTag {
};
ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback);
base::lambda<void()> generateInformCallback(const base::lambda_copy<void()> &closedCallback);
ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda<void()> closedCallback);
base::lambda<void()> generateInformCallback(base::lambda<void()> closedCallback);
friend class InformBox;
void confirmed();
@ -93,8 +93,8 @@ private:
class InformBox : public ConfirmBox {
public:
InformBox(QWidget*, const QString &text, base::lambda_copy<void()> &&closedCallback = base::lambda_copy<void()>());
InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback = base::lambda_copy<void()>());
InformBox(QWidget*, const QString &text, base::lambda<void()> closedCallback = base::lambda<void()>());
InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda<void()> closedCallback = base::lambda<void()>());
};

4
Telegram/SourceFiles/boxes/contactsbox.cpp
View File

@ -528,7 +528,7 @@ bool ContactsBox::creationFail(const RPCError &error) {
ContactsBox::Inner::ContactData::ContactData() = default;
ContactsBox::Inner::ContactData::ContactData(PeerData *peer, const base::lambda_copy<void()> &updateCallback)
ContactsBox::Inner::ContactData::ContactData(PeerData *peer, base::lambda<void()> updateCallback)
: checkbox(std::make_unique<Ui::RoundImageCheckbox>(st::contactsPhotoCheckbox, updateCallback, PaintUserpicCallback(peer))) {
}
@ -1471,7 +1471,7 @@ void ContactsBox::Inner::peerUnselected(PeerData *peer) {
changePeerCheckState(data, peer, false, ChangeStateWay::SkipCallback);
}
void ContactsBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback) {
void ContactsBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback) {
_peerSelectedChangedCallback = std::move(callback);
}

6
Telegram/SourceFiles/boxes/contactsbox.h
View File

@ -152,7 +152,7 @@ public:
Inner(QWidget *parent, ChatData *chat, MembersFilter membersFilter);
Inner(QWidget *parent, UserData *bot);
void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback);
void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback);
void peerUnselected(PeerData *peer);
void updateFilter(QString filter = QString());
@ -164,7 +164,7 @@ public:
QVector<UserData*> selected();
QVector<MTPInputUser> selectedInputs();
bool allAdmins() const;
void setAllAdminsChangedCallback(base::lambda<void()> &&allAdminsChangedCallback) {
void setAllAdminsChangedCallback(base::lambda<void()> allAdminsChangedCallback) {
_allAdminsChangedCallback = std::move(allAdminsChangedCallback);
}
@ -218,7 +218,7 @@ protected:
private:
struct ContactData {
ContactData();
ContactData(PeerData *peer, const base::lambda_copy<void()> &updateCallback);
ContactData(PeerData *peer, base::lambda<void()> updateCallback);
~ContactData();
std::unique_ptr<Ui::RoundImageCheckbox> checkbox;

4
Telegram/SourceFiles/boxes/editcolorbox.h
View File

@ -28,11 +28,11 @@ class EditColorBox : public BoxContent {
public:
EditColorBox(QWidget*, const QString &title, QColor current = QColor(255, 255, 255));
void setSaveCallback(base::lambda<void(QColor)> &&callback) {
void setSaveCallback(base::lambda<void(QColor)> callback) {
_saveCallback = std::move(callback);
}
void setCancelCallback(base::lambda<void()> &&callback) {
void setCancelCallback(base::lambda<void()> callback) {
_cancelCallback = std::move(callback);
}

4
Telegram/SourceFiles/boxes/send_files_box.h
View File

@ -37,10 +37,10 @@ public:
SendFilesBox(QWidget*, const QStringList &files, CompressConfirm compressed);
SendFilesBox(QWidget*, const QString &phone, const QString &firstname, const QString &lastname);
void setConfirmedCallback(base::lambda<void(const QStringList &files, bool compressed, const QString &caption, bool ctrlShiftEnter)> &&callback) {
void setConfirmedCallback(base::lambda<void(const QStringList &files, bool compressed, const QString &caption, bool ctrlShiftEnter)> callback) {
_confirmedCallback = std::move(callback);
}
void setCancelledCallback(base::lambda<void()> &&callback) {
void setCancelledCallback(base::lambda<void()> callback) {
_cancelledCallback = std::move(callback);
}

4
Telegram/SourceFiles/boxes/sharebox.cpp
View File

@ -513,7 +513,7 @@ void ShareBox::Inner::paintChat(Painter &p, TimeMs ms, Chat *chat, int index) {
chat->name.drawLeftElided(p, x + nameLeft, y + nameTop, nameWidth, outerWidth, 2, style::al_top, 0, -1, 0, true);
}
ShareBox::Inner::Chat::Chat(PeerData *peer, const base::lambda_copy<void()> &updateCallback)
ShareBox::Inner::Chat::Chat(PeerData *peer, base::lambda<void()> updateCallback)
: peer(peer)
, checkbox(st::sharePhotoCheckbox, updateCallback, PaintUserpicCallback(peer))
, name(st::sharePhotoCheckbox.imageRadius * 2) {
@ -649,7 +649,7 @@ void ShareBox::Inner::peerUnselected(PeerData *peer) {
changePeerCheckState(chat, false, ChangeStateWay::SkipCallback);
}
void ShareBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback) {
void ShareBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback) {
_peerSelectedChangedCallback = std::move(callback);
}

4
Telegram/SourceFiles/boxes/sharebox.h
View File

@ -114,7 +114,7 @@ class ShareBox::Inner : public TWidget, public RPCSender, private base::Subscrib
public:
Inner(QWidget *parent, ShareBox::FilterCallback &&filterCallback);
void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback);
void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback);
void peerUnselected(PeerData *peer);
QVector<PeerData*> selected() const;
@ -153,7 +153,7 @@ private:
int displayedChatsCount() const;
struct Chat {
Chat(PeerData *peer, const base::lambda_copy<void()> &updateCallback);
Chat(PeerData *peer, base::lambda<void()> updateCallback);
PeerData *peer;
Ui::RoundImageCheckbox checkbox;

4
Telegram/SourceFiles/boxes/stickers_box.h
View File

@ -163,10 +163,10 @@ public:
void setFullOrder(const Stickers::Order &order);
void setRemovedSets(const Stickers::Order &removed);
void setInstallSetCallback(base::lambda<void(uint64 setId)> &&callback) {
void setInstallSetCallback(base::lambda<void(uint64 setId)> callback) {
_installSetCallback = std::move(callback);
}
void setLoadMoreCallback(base::lambda<void()> &&callback) {
void setLoadMoreCallback(base::lambda<void()> callback) {
_loadMoreCallback = std::move(callback);
}

2
Telegram/SourceFiles/core/click_handler.h
View File

@ -180,7 +180,7 @@ protected:
class LambdaClickHandler : public ClickHandler {
public:
LambdaClickHandler(base::lambda<void()> &&handler) : _handler(std::move(handler)) {
LambdaClickHandler(base::lambda<void()> handler) : _handler(std::move(handler)) {
}
void onClick(Qt::MouseButton button) const override final {
if (button == Qt::LeftButton && _handler) {

856
Telegram/SourceFiles/core/lambda.h
View File

@ -23,415 +23,454 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
#include <memory>
namespace base {
namespace internal {
template <typename Return, typename ...Args>
struct lambda_wrap_helper_base {
using construct_copy_other_type = void(*)(void *, const void *); // dst, src
using construct_move_other_type = void(*)(void *, void *); // dst, src
using call_type = Return(*)(const void *, Args...);
using destruct_type = void(*)(const void *);
lambda_wrap_helper_base() = delete;
lambda_wrap_helper_base(const lambda_wrap_helper_base &other) = delete;
lambda_wrap_helper_base &operator=(const lambda_wrap_helper_base &other) = delete;
lambda_wrap_helper_base(
construct_copy_other_type construct_copy_other,
construct_move_other_type construct_move_other,
call_type call,
destruct_type destruct)
: construct_copy_other(construct_copy_other)
, construct_move_other(construct_move_other)
, call(call)
, destruct(destruct) {
}
const construct_copy_other_type construct_copy_other;
const construct_move_other_type construct_move_other;
const call_type call;
const destruct_type destruct;
static constexpr size_t kFullStorageSize = 24U + sizeof(void*);
static constexpr size_t kStorageSize = kFullStorageSize - sizeof(void*);
using alignment = uint64;
template <typename Lambda>
using IsLarge = std::integral_constant<bool, !(sizeof(std::decay_t<Lambda>) <= kStorageSize)>;
protected:
static void bad_construct_copy(void *lambda, const void *source) {
t_assert(!"base::lambda bad_construct_copy() called!");
}
};
template <typename Return, typename ...Args>
struct lambda_wrap_empty : public lambda_wrap_helper_base<Return, Args...> {
static void construct_copy_other_method(void *lambda, const void *source) {
}
static void construct_move_other_method(void *lambda, void *source) {
}
static Return call_method(const void *lambda, Args... args) {
t_assert(!"base::lambda empty call_method() called!");
return Return();
}
static void destruct_method(const void *lambda) {
}
lambda_wrap_empty() : lambda_wrap_helper_base<Return, Args...>(
&lambda_wrap_empty::construct_copy_other_method,
&lambda_wrap_empty::construct_move_other_method,
&lambda_wrap_empty::call_method,
&lambda_wrap_empty::destruct_method) {
}
static const lambda_wrap_empty<Return, Args...> instance;
};
template <typename Return, typename ...Args>
const lambda_wrap_empty<Return, Args...> lambda_wrap_empty<Return, Args...>::instance = {};
template <typename Lambda, typename IsLarge, typename Return, typename ...Args> struct lambda_wrap_helper_move_impl;
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_move_impl<Lambda, std::true_type, Return, Args...> : public lambda_wrap_helper_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = lambda_wrap_helper_base<Return, Args...>;
static void construct_move_other_method(void *lambda, void *source) {
auto source_lambda = static_cast<LambdaPtr*>(source);
new (lambda) LambdaPtr(std::move(*source_lambda));
}
static void construct_move_lambda_method(void *lambda, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (lambda) LambdaPtr(std::make_unique<JustLambda>(static_cast<JustLambda&&>(*source_lambda)));
}
static Return call_method(const void *lambda, Args... args) {
return (**static_cast<const LambdaPtr*>(lambda))(std::forward<Args>(args)...);
}
static void destruct_method(const void *lambda) {
static_cast<const LambdaPtr*>(lambda)->~LambdaPtr();
}
lambda_wrap_helper_move_impl() : Parent(
&Parent::bad_construct_copy,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
protected:
lambda_wrap_helper_move_impl(
typename Parent::construct_copy_other_type construct_copy_other
) : Parent(
construct_copy_other,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_move_impl<Lambda, std::false_type, Return, Args...> : public lambda_wrap_helper_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = lambda_wrap_helper_base<Return, Args...>;
static void construct_move_other_method(void *lambda, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (lambda) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
static void construct_move_lambda_method(void *lambda, void *source) {
static_assert(alignof(JustLambda) <= alignof(typename Parent::alignment), "Bad lambda alignment.");
auto space = sizeof(JustLambda);
auto aligned = std::align(alignof(JustLambda), space, lambda, space);
t_assert(aligned == lambda);
auto source_lambda = static_cast<JustLambda*>(source);
new (lambda) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
static Return call_method(const void *lambda, Args... args) {
return (*static_cast<const JustLambda*>(lambda))(std::forward<Args>(args)...);
}
static void destruct_method(const void *lambda) {
static_cast<const JustLambda*>(lambda)->~JustLambda();
}
lambda_wrap_helper_move_impl() : Parent(
&Parent::bad_construct_copy,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
protected:
lambda_wrap_helper_move_impl(
typename Parent::construct_copy_other_type construct_copy_other
) : Parent(
construct_copy_other,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_move : public lambda_wrap_helper_move_impl<Lambda
, typename lambda_wrap_helper_base<Return, Args...>::template IsLarge<Lambda>
, Return, Args...> {
static const lambda_wrap_helper_move instance;
};
template <typename Lambda, typename Return, typename ...Args>
const lambda_wrap_helper_move<Lambda, Return, Args...> lambda_wrap_helper_move<Lambda, Return, Args...>::instance = {};
template <typename Lambda, typename IsLarge, typename Return, typename ...Args> struct lambda_wrap_helper_copy_impl;
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_copy_impl<Lambda, std::true_type, Return, Args...> : public lambda_wrap_helper_move_impl<Lambda, std::true_type, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = lambda_wrap_helper_move_impl<Lambda, std::true_type, Return, Args...>;
static void construct_copy_other_method(void *lambda, const void *source) {
auto source_lambda = static_cast<const LambdaPtr*>(source);
new (lambda) LambdaPtr(std::make_unique<JustLambda>(*source_lambda->get()));
}
static void construct_copy_lambda_method(void *lambda, const void *source) {
auto source_lambda = static_cast<const JustLambda*>(source);
new (lambda) LambdaPtr(std::make_unique<JustLambda>(static_cast<const JustLambda &>(*source_lambda)));
}
lambda_wrap_helper_copy_impl() : Parent(&lambda_wrap_helper_copy_impl::construct_copy_other_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_copy_impl<Lambda, std::false_type, Return, Args...> : public lambda_wrap_helper_move_impl<Lambda, std::false_type, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = lambda_wrap_helper_move_impl<Lambda, std::false_type, Return, Args...>;
static void construct_copy_other_method(void *lambda, const void *source) {
auto source_lambda = static_cast<const JustLambda*>(source);
new (lambda) JustLambda(static_cast<const JustLambda &>(*source_lambda));
}
static void construct_copy_lambda_method(void *lambda, const void *source) {
static_assert(alignof(JustLambda) <= alignof(typename Parent::alignment), "Bad lambda alignment.");
auto space = sizeof(JustLambda);
auto aligned = std::align(alignof(JustLambda), space, lambda, space);
t_assert(aligned == lambda);
auto source_lambda = static_cast<const JustLambda*>(source);
new (lambda) JustLambda(static_cast<const JustLambda &>(*source_lambda));
}
lambda_wrap_helper_copy_impl() : Parent(&lambda_wrap_helper_copy_impl::construct_copy_other_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_copy : public lambda_wrap_helper_copy_impl<Lambda
, typename lambda_wrap_helper_base<Return, Args...>::template IsLarge<Lambda>
, Return, Args...> {
static const lambda_wrap_helper_copy instance;
};
template <typename Lambda, typename Return, typename ...Args>
const lambda_wrap_helper_copy<Lambda, Return, Args...> lambda_wrap_helper_copy<Lambda, Return, Args...>::instance = {};
} // namespace internal
template <typename Function> class lambda_once;
template <typename Function> class lambda;
template <typename Function> class lambda_copy;
template <typename Return, typename ...Args>
class lambda<Return(Args...)> {
using BaseHelper = internal::lambda_wrap_helper_base<Return, Args...>;
using EmptyHelper = internal::lambda_wrap_empty<Return, Args...>;
template <typename Lambda>
using IsUnique = std::is_same<lambda, std::decay_t<Lambda>>;
template <typename Lambda>
using IsWrap = std::is_same<lambda_copy<Return(Args...)>, std::decay_t<Lambda>>;
template <typename Lambda>
using IsOther = std::enable_if_t<!IsUnique<Lambda>::value && !IsWrap<Lambda>::value>;
template <typename Lambda>
using IsRvalue = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>;
public:
using return_type = Return;
lambda() : helper_(&EmptyHelper::instance) {
}
lambda(const lambda &other) = delete;
lambda &operator=(const lambda &other) = delete;
lambda(lambda &&other) : helper_(other.helper_) {
helper_->construct_move_other(storage_, other.storage_);
}
lambda &operator=(lambda &&other) {
auto temp = std::move(other);
helper_->destruct(storage_);
helper_ = temp.helper_;
helper_->construct_move_other(storage_, temp.storage_);
return *this;
}
void swap(lambda &other) {
if (this != &other) std::swap(*this, other);
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda(Lambda &&other) : helper_(&internal::lambda_wrap_helper_move<Lambda, Return, Args...>::instance) {
internal::lambda_wrap_helper_move<Lambda, Return, Args...>::construct_move_lambda_method(storage_, &other);
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda &operator=(Lambda &&other) {
auto temp = std::move(other);
helper_->destruct(storage_);
helper_ = &internal::lambda_wrap_helper_move<Lambda, Return, Args...>::instance;
internal::lambda_wrap_helper_move<Lambda, Return, Args...>::construct_move_lambda_method(storage_, &temp);
return *this;
}
inline Return operator()(Args... args) const {
return helper_->call(storage_, std::forward<Args>(args)...);
}
explicit operator bool() const {
return (helper_ != &EmptyHelper::instance);
}
~lambda() {
helper_->destruct(storage_);
}
protected:
struct Private {
};
lambda(const BaseHelper *helper, const Private &) : helper_(helper) {
}
using alignment = typename BaseHelper::alignment;
static_assert(BaseHelper::kStorageSize % sizeof(alignment) == 0, "Bad storage size.");
alignas(typename BaseHelper::alignment) alignment storage_[BaseHelper::kStorageSize / sizeof(alignment)];
const BaseHelper *helper_;
};
template <typename Return, typename ...Args>
class lambda_copy<Return(Args...)> : public lambda<Return(Args...)> {
using BaseHelper = internal::lambda_wrap_helper_base<Return, Args...>;
using Parent = lambda<Return(Args...)>;
template <typename Lambda>
using IsOther = std::enable_if_t<!std::is_same<lambda_copy, std::decay_t<Lambda>>::value>;
template <typename Lambda>
using IsRvalue = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>;
template <typename Lambda>
using IsNotRvalue = std::enable_if_t<!std::is_rvalue_reference<Lambda&&>::value>;
public:
lambda_copy() = default;
lambda_copy(const lambda_copy &other) : Parent(other.helper_, typename Parent::Private()) {
this->helper_->construct_copy_other(this->storage_, other.storage_);
}
lambda_copy &operator=(const lambda_copy &other) {
auto temp = other;
temp.swap(*this);
return *this;
}
lambda_copy(lambda_copy &&other) = default;
lambda_copy &operator=(lambda_copy &&other) = default;
void swap(lambda_copy &other) {
if (this != &other) std::swap(*this, other);
}
lambda_copy clone() const {
return *this;
}
template <typename Lambda, typename = IsOther<Lambda>>
lambda_copy(const Lambda &other) : Parent(&internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance, typename Parent::Private()) {
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_copy_lambda_method(this->storage_, &other);
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda_copy(Lambda &&other) : Parent(&internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance, typename Parent::Private()) {
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_move_lambda_method(this->storage_, &other);
}
template <typename Lambda, typename = IsOther<Lambda>>
lambda_copy &operator=(const Lambda &other) {
auto temp = other;
this->helper_->destruct(this->storage_);
this->helper_ = &internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance;
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_copy_lambda_method(this->storage_, &other);
return *this;
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda_copy &operator=(Lambda &&other) {
auto temp = std::move(other);
this->helper_->destruct(this->storage_);
this->helper_ = &internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance;
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_move_lambda_method(this->storage_, &other);
return *this;
}
};
// Get lambda type from a lambda template parameter.
namespace internal {
namespace lambda_internal {
template <typename FunctionType>
struct lambda_type_resolver;
struct type_resolver;
template <typename Lambda, typename R, typename ...Args>
struct lambda_type_resolver<R(Lambda::*)(Args...) const> {
struct type_resolver<R(Lambda::*)(Args...) const> {
using type = lambda<R(Args...)>;
static constexpr auto is_mutable = false;
};
template <typename Lambda, typename R, typename ...Args>
struct lambda_type_resolver<R(Lambda::*)(Args...)> {
struct type_resolver<R(Lambda::*)(Args...)> {
using type = lambda<R(Args...)>;
static constexpr auto is_mutable = true;
};
template <typename FunctionType>
struct lambda_type_helper {
using type = typename lambda_type_resolver<decltype(&FunctionType::operator())>::type;
template <typename Lambda>
struct type_helper {
using type = typename type_resolver<decltype(&Lambda::operator())>::type;
static constexpr auto is_mutable = type_resolver<decltype(&Lambda::operator())>::is_mutable;
};
} // namespace internal
} // namespace lambda_internal
template <typename FunctionType>
using lambda_type = typename internal::lambda_type_helper<FunctionType>::type;
template <typename Lambda>
using lambda_type = typename lambda_internal::type_helper<std::decay_t<Lambda>>::type;
template <typename Lambda>
constexpr bool lambda_is_mutable = lambda_internal::type_helper<std::decay_t<Lambda>>::is_mutable;
namespace lambda_internal {
constexpr auto kFullStorageSize = 32U;
static_assert(kFullStorageSize % sizeof(void*) == 0, "Invalid pointer size!");
constexpr auto kStorageSize = kFullStorageSize - sizeof(void*);
using alignment = std::max_align_t;
template <typename Lambda>
constexpr bool is_large = (sizeof(std::decay_t<Lambda>) > kStorageSize);
inline void bad_construct_copy(void *lambda, const void *source) {
t_assert(!"base::lambda bad_construct_copy() called!");
}
template <typename Return, typename ...Args>
Return bad_const_call(const void *lambda, Args...) {
t_assert(!"base::lambda bad_const_call() called!");
return Return();
}
template <typename Return, typename ...Args>
struct vtable_base {
using construct_copy_other_type = void(*)(void *, const void *); // dst, src
using construct_move_other_type = void(*)(void *, void *); // dst, src
using const_call_type = Return(*)(const void *, Args...);
using call_type = Return(*)(void *, Args...);
using destruct_type = void(*)(const void *);
vtable_base() = delete;
vtable_base(const vtable_base &other) = delete;
vtable_base &operator=(const vtable_base &other) = delete;
vtable_base(
construct_copy_other_type construct_copy_other,
construct_move_other_type construct_move_other,
const_call_type const_call,
call_type call,
destruct_type destruct)
: construct_copy_other(construct_copy_other)
, construct_move_other(construct_move_other)
, const_call(const_call)
, call(call)
, destruct(destruct) {
}
const construct_copy_other_type construct_copy_other;
const construct_move_other_type construct_move_other;
const const_call_type const_call;
const call_type call;
const destruct_type destruct;
};
template <typename Lambda, bool IsLarge, typename Return, typename ...Args> struct vtable_once_impl;
template <typename Lambda, typename Return, typename ...Args>
struct vtable_once_impl<Lambda, true, Return, Args...> : public vtable_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = vtable_base<Return, Args...>;
static void construct_move_other_method(void *storage, void *source) {
auto source_lambda_ptr = static_cast<LambdaPtr*>(source);
new (storage) LambdaPtr(std::move(*source_lambda_ptr));
}
static Return call_method(void *storage, Args... args) {
return (**static_cast<LambdaPtr*>(storage))(std::forward<Args>(args)...);
}
static void destruct_method(const void *storage) {
static_cast<const LambdaPtr*>(storage)->~LambdaPtr();
}
vtable_once_impl() : Parent(
&bad_construct_copy,
&vtable_once_impl::construct_move_other_method,
&bad_const_call<Return, Args...>,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
// Used directly.
static void construct_move_lambda_method(void *storage, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (storage) LambdaPtr(std::make_unique<JustLambda>(static_cast<JustLambda&&>(*source_lambda)));
}
protected:
vtable_once_impl(
typename Parent::construct_copy_other_type construct_copy_other,
typename Parent::const_call_type const_call
) : Parent(
construct_copy_other,
&vtable_once_impl::construct_move_other_method,
const_call,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable_once_impl<Lambda, false, Return, Args...> : public vtable_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = vtable_base<Return, Args...>;
static void construct_move_other_method(void *storage, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (storage) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
static Return call_method(void *storage, Args... args) {
return (*static_cast<JustLambda*>(storage))(std::forward<Args>(args)...);
}
static void destruct_method(const void *storage) {
static_cast<const JustLambda*>(storage)->~JustLambda();
}
vtable_once_impl() : Parent(
&bad_construct_copy,
&vtable_once_impl::construct_move_other_method,
&bad_const_call<Args...>,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
// Used directly.
static void construct_move_lambda_method(void *storage, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (storage) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
protected:
vtable_once_impl(
typename Parent::construct_copy_other_type construct_copy_other,
typename Parent::const_call_type const_call
) : Parent(
construct_copy_other,
&vtable_once_impl::construct_move_other_method,
const_call,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable_once : public vtable_once_impl<Lambda, is_large<Lambda>, Return, Args...> {
static const vtable_once instance;
};
template <typename Lambda, typename Return, typename ...Args>
const vtable_once<Lambda, Return, Args...> vtable_once<Lambda, Return, Args...>::instance = {};
template <typename Lambda, bool IsLarge, typename Return, typename ...Args> struct vtable_impl;
template <typename Lambda, typename Return, typename ...Args>
struct vtable_impl<Lambda, true, Return, Args...> : public vtable_once_impl<Lambda, true, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = vtable_once_impl<Lambda, true, Return, Args...>;
static void construct_copy_other_method(void *storage, const void *source) {
auto source_lambda = static_cast<const LambdaPtr*>(source);
new (storage) LambdaPtr(std::make_unique<JustLambda>(*source_lambda->get()));
}
static Return const_call_method(const void *storage, Args... args) {
auto lambda_ptr = static_cast<const LambdaPtr*>(storage)->get();
return (*static_cast<const JustLambda*>(lambda_ptr))(std::forward<Args>(args)...);
}
vtable_impl() : Parent(
&vtable_impl::construct_copy_other_method,
&vtable_impl::const_call_method
) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable_impl<Lambda, false, Return, Args...> : public vtable_once_impl<Lambda, false, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = vtable_once_impl<Lambda, false, Return, Args...>;
static void construct_copy_other_method(void *storage, const void *source) {
auto source_lambda = static_cast<const JustLambda*>(source);
new (storage) JustLambda(static_cast<const JustLambda &>(*source_lambda));
}
static Return const_call_method(const void *storage, Args... args) {
static_assert(!lambda_is_mutable<JustLambda>, "For mutable lambda use base::lambda_once wrapper");
return (*static_cast<const JustLambda*>(storage))(std::forward<Args>(args)...);
}
vtable_impl() : Parent(
&vtable_impl::construct_copy_other_method,
&vtable_impl::const_call_method
) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable : public vtable_impl<Lambda, is_large<Lambda>, Return, Args...> {
static const vtable instance;
};
template <typename Lambda, typename Return, typename ...Args>
const vtable<Lambda, Return, Args...> vtable<Lambda, Return, Args...>::instance = {};
} // namespace lambda_internal
template <typename Return, typename ...Args>
class lambda_once<Return(Args...)> {
using VTable = lambda_internal::vtable_base<Return, Args...>;
public:
using return_type = Return;
lambda_once() {
data_.vtable = nullptr;
}
lambda_once(const lambda_once &other) = delete;
lambda_once &operator=(const lambda_once &other) = delete;
// Move construct / assign from the same type.
lambda_once(lambda_once &&other) {
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
}
}
lambda_once &operator=(lambda_once &&other) {
if (this != &other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
data_.vtable->destruct(other.data_.storage);
other.data_.vtable = nullptr;
}
}
return *this;
}
// Move construct / assign from a derived type.
lambda_once(lambda<Return(Args...)> &&other) {
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
data_.vtable->destruct(other.data_.storage);
other.data_.vtable = nullptr;
}
}
lambda_once &operator=(lambda<Return(Args...)> &&other) {
if (this != &other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
data_.vtable->destruct(other.data_.storage);
other.data_.vtable = nullptr;
}
}
return *this;
}
// Copy construct / assign from a derived type.
lambda_once(const lambda<Return(Args...)> &other) {
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_copy_other(data_.storage, other.data_.storage);
}
}
lambda_once &operator=(const lambda<Return(Args...)> &other) {
if (this != &other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_copy_other(data_.storage, other.data_.storage);
}
}
return *this;
}
// Copy / move construct / assign from an arbitrary type.
template <typename Lambda>
lambda_once(Lambda other) {
data_.vtable = &lambda_internal::vtable_once<Lambda, Return, Args...>::instance;
lambda_internal::vtable_once<Lambda, Return, Args...>::construct_move_lambda_method(data_.storage, &other);
}
template <typename Lambda>
lambda_once &operator=(Lambda other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
data_.vtable = &lambda_internal::vtable_once<Lambda, Return, Args...>::instance;
lambda_internal::vtable_once<Lambda, Return, Args...>::construct_move_lambda_method(data_.storage, &other);
return *this;
}
void swap(lambda_once &other) {
if (this != &other) {
std::swap(*this, other);
}
}
inline Return operator()(Args... args) {
t_assert(data_.vtable != nullptr);
return data_.vtable->call(data_.storage, std::forward<Args>(args)...);
}
explicit operator bool() const {
return (data_.vtable != nullptr);
}
~lambda_once() {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
}
protected:
struct Private {
};
lambda_once(const VTable *vtable, const Private &) {
data_.vtable = vtable;
}
struct Data {
char storage[lambda_internal::kStorageSize];
const VTable *vtable;
};
union {
lambda_internal::alignment alignment_;
char raw_[lambda_internal::kFullStorageSize];
Data data_;
};
};
template <typename Return, typename ...Args>
class lambda<Return(Args...)> final : public lambda_once<Return(Args...)> {
using Parent = lambda_once<Return(Args...)>;
public:
lambda() = default;
// Move construct / assign from the same type.
lambda(lambda<Return(Args...)> &&other) : Parent(std::move(other)) {
}
lambda &operator=(lambda<Return(Args...)> &&other) {
Parent::operator=(std::move(other));
return *this;
}
// Copy construct / assign from the same type.
lambda(const lambda<Return(Args...)> &other) : Parent(other) {
}
lambda &operator=(const lambda<Return(Args...)> &other) {
Parent::operator=(other);
return *this;
}
// Copy / move construct / assign from an arbitrary type.
template <typename Lambda>
lambda(Lambda other) : Parent(&lambda_internal::vtable<Lambda, Return, Args...>::instance, typename Parent::Private()) {
lambda_internal::vtable<Lambda, Return, Args...>::construct_move_lambda_method(this->data_.storage, &other);
}
template <typename Lambda>
lambda &operator=(Lambda other) {
if (this->data_.vtable) {
this->data_.vtable->destruct(this->data_.storage);
}
this->data_.vtable = &lambda_internal::vtable<Lambda, Return, Args...>::instance;
lambda_internal::vtable<Lambda, Return, Args...>::construct_move_lambda_method(this->data_.storage, &other);
return *this;
}
inline Return operator()(Args... args) const {
t_assert(this->data_.vtable != nullptr);
return this->data_.vtable->const_call(this->data_.storage, std::forward<Args>(args)...);
}
void swap(lambda &other) {
if (this != &other) {
std::swap(*this, other);
}
}
};
// Guard lambda call by one or many QObject* weak pointers.
namespace internal {
template <int N>
class lambda_guard_creator;
namespace lambda_internal {
template <int N, typename Lambda>
class lambda_guard_data {
class guard_data {
public:
using return_type = typename lambda_type<Lambda>::return_type;
template <typename ...PointersAndLambda>
inline lambda_guard_data(PointersAndLambda&&... qobjectsAndLambda) : _lambda(init(_pointers, std::forward<PointersAndLambda>(qobjectsAndLambda)...)) {
inline guard_data(PointersAndLambda&&... qobjectsAndLambda) : _lambda(init(_pointers, std::forward<PointersAndLambda>(qobjectsAndLambda)...)) {
}
inline lambda_guard_data(const lambda_guard_data &other) : _lambda(other._lambda) {
inline guard_data(const guard_data &other) : _lambda(other._lambda) {
for (auto i = 0; i != N; ++i) {
_pointers[i] = other._pointers[i];
}
}
template <typename ...Args>
inline return_type operator()(Args&&... args) {
for (int i = 0; i != N; ++i) {
if (!_pointers[i]) {
return return_type();
}
}
return _lambda(std::forward<Args>(args)...);
}
template <typename ...Args>
inline return_type operator()(Args&&... args) const {
for (int i = 0; i != N; ++i) {
@ -458,31 +497,36 @@ private:
};
template <int N, typename Lambda>
class lambda_guard {
class guard {
public:
using return_type = typename lambda_type<Lambda>::return_type;
template <typename ...PointersAndLambda>
inline lambda_guard(PointersAndLambda&&... qobjectsAndLambda) : _data(std::make_unique<lambda_guard_data<N, Lambda>>(std::forward<PointersAndLambda>(qobjectsAndLambda)...)) {
inline guard(PointersAndLambda&&... qobjectsAndLambda) : _data(std::make_unique<guard_data<N, Lambda>>(std::forward<PointersAndLambda>(qobjectsAndLambda)...)) {
static_assert(sizeof...(PointersAndLambda) == N + 1, "Wrong argument count!");
}
inline lambda_guard(const lambda_guard &&other) : _data(std::move(other._data)) {
inline guard(const guard &other) : _data(std::make_unique<guard_data<N, Lambda>>(static_cast<const guard_data<N, Lambda> &>(*other._data))) {
}
inline lambda_guard(lambda_guard &&other) : _data(std::move(other._data)) {
inline guard(guard &&other) : _data(std::move(other._data)) {
}
inline lambda_guard &operator=(const lambda_guard &&other) {
inline guard &operator=(const guard &&other) {
_data = std::move(other._data);
return *this;
}
inline lambda_guard &operator=(lambda_guard &&other) {
inline guard &operator=(guard &&other) {
_data = std::move(other._data);
return *this;
}
template <typename ...Args>
inline return_type operator()(Args&&... args) {
return (*_data)(std::forward<Args>(args)...);
}
template <typename ...Args>
inline return_type operator()(Args&&... args) const {
return (*_data)(std::forward<Args>(args)...);
@ -492,51 +536,45 @@ public:
return !_data;
}
lambda_guard clone() const {
return lambda_guard(*this);
}
private:
inline lambda_guard(const lambda_guard &other) : _data(std::make_unique<lambda_guard_data<N, Lambda>>(static_cast<const lambda_guard_data<N, Lambda> &>(*other._data))) {
}
mutable std::unique_ptr<lambda_guard_data<N, Lambda>> _data;
mutable std::unique_ptr<guard_data<N, Lambda>> _data;
};
template <int N, int K, typename ...PointersAndLambda>
struct lambda_guard_type;
struct guard_type;
template <int N, int K, typename Pointer, typename ...PointersAndLambda>
struct lambda_guard_type<N, K, Pointer, PointersAndLambda...> {
using type = typename lambda_guard_type<N, K - 1, PointersAndLambda...>::type;
struct guard_type<N, K, Pointer, PointersAndLambda...> {
using type = typename guard_type<N, K - 1, PointersAndLambda...>::type;
};
template <int N, typename Lambda>
struct lambda_guard_type<N, 0, Lambda> {
using type = lambda_guard<N, Lambda>;
struct guard_type<N, 0, Lambda> {
using type = guard<N, Lambda>;
};
template <typename ...PointersAndLambda>
struct lambda_guard_type_helper {
struct guard_type_helper {
static constexpr int N = sizeof...(PointersAndLambda);
using type = typename lambda_guard_type<N - 1, N - 1, PointersAndLambda...>::type;
using type = typename guard_type<N - 1, N - 1, PointersAndLambda...>::type;
};
template <typename ...PointersAndLambda>
using lambda_guard_t = typename lambda_guard_type_helper<PointersAndLambda...>::type;
using guard_t = typename guard_type_helper<PointersAndLambda...>::type;
template <int N, typename Lambda>
struct lambda_type_helper<lambda_guard<N, Lambda>> {
using type = typename lambda_type_helper<Lambda>::type;
struct type_helper<guard<N, Lambda>> {
using type = typename type_helper<Lambda>::type;
static constexpr auto is_mutable = type_helper<Lambda>::is_mutable;
};
} // namespace internal
} // namespace lambda_internal
template <typename ...PointersAndLambda>
inline internal::lambda_guard_t<PointersAndLambda...> lambda_guarded(PointersAndLambda&&... qobjectsAndLambda) {
inline lambda_internal::guard_t<PointersAndLambda...> lambda_guarded(PointersAndLambda&&... qobjectsAndLambda) {
static_assert(sizeof...(PointersAndLambda) > 0, "Lambda should be passed here.");
return internal::lambda_guard_t<PointersAndLambda...>(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
return lambda_internal::guard_t<PointersAndLambda...>(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
}
// Pass lambda instead of a Qt void() slot.
@ -545,20 +583,20 @@ class lambda_slot_wrap : public QObject {
Q_OBJECT
public:
lambda_slot_wrap(QObject *parent, lambda<void()> &&lambda) : QObject(parent), _lambda(std::move(lambda)) {
lambda_slot_wrap(QObject *parent, lambda_once<void()> lambda) : QObject(parent), _lambda(std::move(lambda)) {
}
public slots:
void action() {
public slots :
void action() {
_lambda();
}
private:
lambda<void()> _lambda;
lambda_once<void()> _lambda;
};
inline lambda_slot_wrap *lambda_slot(QObject *parent, lambda<void()> &&lambda) {
inline lambda_slot_wrap *lambda_slot(QObject *parent, lambda_once<void()> lambda) {
return new lambda_slot_wrap(parent, std::move(lambda));
}
@ -566,21 +604,21 @@ class lambda_slot_once_wrap : public QObject {
Q_OBJECT
public:
lambda_slot_once_wrap(QObject *parent, lambda<void()> &&lambda) : QObject(parent), _lambda(std::move(lambda)) {
lambda_slot_once_wrap(QObject *parent, lambda_once<void()> lambda) : QObject(parent), _lambda(std::move(lambda)) {
}
public slots :
void action() {
public slots :
void action() {
_lambda();
delete this;
}
private:
lambda<void()> _lambda;
lambda_once<void()> _lambda;
};
inline lambda_slot_once_wrap *lambda_slot_once(QObject *parent, lambda<void()> &&lambda) {
inline lambda_slot_once_wrap *lambda_slot_once(QObject *parent, lambda_once<void()> lambda) {
return new lambda_slot_once_wrap(parent, std::move(lambda));
}

2
Telegram/SourceFiles/core/single_timer.cpp
View File

@ -28,7 +28,7 @@ SingleTimer::SingleTimer(QObject *parent) : QTimer(parent) {
Sandbox::connect(SIGNAL(adjustSingleTimers()), this, SLOT(adjust()));
}
void SingleTimer::setTimeoutHandler(base::lambda<void()> &&handler) {
void SingleTimer::setTimeoutHandler(base::lambda<void()> handler) {
if (_handler && !handler) {
disconnect(this, SIGNAL(timeout()), this, SLOT(onTimeout()));
} else if (handler && !_handler) {

2
Telegram/SourceFiles/core/single_timer.h
View File

@ -31,7 +31,7 @@ public:
void setSingleShot(bool); // is not available
void start(); // is not available
void setTimeoutHandler(base::lambda<void()> &&handler);
void setTimeoutHandler(base::lambda<void()> handler);
public slots:
void start(int msec);

19
Telegram/SourceFiles/core/task_queue.cpp
View File

@ -195,7 +195,7 @@ TaskQueue *TaskQueue::TaskQueueList::TakeFirst(int list_index_) {
void TaskQueue::TaskThreadPool::AddQueueTask(TaskQueue *queue, Task &&task) {
QMutexLocker lock(&queues_mutex_);
queue->tasks_.push_back(new Task(std::move(task)));
queue->tasks_.push_back(std::move(task));
auto list_was_empty = queue_list_.Empty(kAllQueuesList);
auto threads_count = threads_.size();
auto all_threads_processing = (threads_count == tasks_in_process_);
@ -258,7 +258,7 @@ void TaskQueue::TaskThreadPool::ThreadFunction() {
bool serial_queue_destroyed = false;
bool task_was_processed = false;
while (true) {
std::unique_ptr<Task> task;
Task task;
{
QMutexLocker lock(&queues_mutex_);
@ -297,7 +297,7 @@ void TaskQueue::TaskThreadPool::ThreadFunction() {
t_assert(!queue->tasks_.empty());
task.reset(queue->tasks_.front());
task = std::move(queue->tasks_.front());
queue->tasks_.pop_front();
if (queue->type_ == Type::Serial) {
@ -318,7 +318,7 @@ void TaskQueue::TaskThreadPool::ThreadFunction() {
}
}
(*task)();
task();
}
}
@ -336,15 +336,12 @@ TaskQueue::~TaskQueue() {
thread_pool->RemoveQueue(this);
}
}
for (auto task : take(tasks_)) {
delete task;
}
}
void TaskQueue::Put(Task &&task) {
if (type_ == Type::Main) {
QMutexLocker lock(&tasks_mutex_);
tasks_.push_back(new Task(std::move(task)));
tasks_.push_back(std::move(task));
Sandbox::MainThreadTaskAdded();
} else {
@ -372,7 +369,7 @@ void TaskQueue::ProcessMainTasks(TimeMs max_time_spent) { // static
}
bool TaskQueue::ProcessOneMainTask() { // static
std::unique_ptr<Task> task;
Task task;
{
QMutexLocker lock(&Main().tasks_mutex_);
auto &tasks = Main().tasks_;
@ -380,11 +377,11 @@ bool TaskQueue::ProcessOneMainTask() { // static
return false;
}
task.reset(tasks.front());
task = std::move(tasks.front());
tasks.pop_front();
}
(*task)();
task();
return true;
}

4
Telegram/SourceFiles/core/task_queue.h
View File

@ -22,7 +22,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
namespace base {
using Task = lambda<void()>;
using Task = lambda_once<void()>;
// An attempt to create/use a TaskQueue or one of the default queues
// after the main() has returned leads to an undefined behaviour.
@ -69,7 +69,7 @@ private:
const Type type_;
const Priority priority_;
QList<Task*> tasks_; // TODO: std::deque<Task>
std::deque<Task> tasks_;
QMutex tasks_mutex_; // Only for the main queue.
// Only for the other queues, not main.

2
Telegram/SourceFiles/dialogs/dialogs_row.cpp
View File

@ -30,7 +30,7 @@ namespace Dialogs {
RippleRow::RippleRow() = default;
RippleRow::~RippleRow() = default;
void RippleRow::addRipple(QPoint origin, QSize size, base::lambda_copy<void()> &&updateCallback) {
void RippleRow::addRipple(QPoint origin, QSize size, base::lambda<void()> updateCallback) {
if (!_ripple) {
auto mask = Ui::RippleAnimation::rectMask(size);
_ripple = std::make_unique<Ui::RippleAnimation>(st::dialogsRipple, std::move(mask), std::move(updateCallback));

2
Telegram/SourceFiles/dialogs/dialogs_row.h
View File

@ -39,7 +39,7 @@ public:
RippleRow();
~RippleRow();
void addRipple(QPoint origin, QSize size, base::lambda_copy<void()> &&updateCallback);
void addRipple(QPoint origin, QSize size, base::lambda<void()> updateCallback);
void stopLastRipple();
void paintRipple(Painter &p, int x, int y, int outerWidth, TimeMs ms, const QColor *colorOverride = nullptr) const;

2
Telegram/SourceFiles/dialogswidget.cpp
View File

@ -1185,7 +1185,7 @@ void DialogsInner::contextMenuEvent(QContextMenuEvent *e) {
}
_menu = new Ui::PopupMenu(nullptr);
App::main()->fillPeerMenu(_menuPeer, [this](const QString &text, base::lambda<void()> &&callback) {
App::main()->fillPeerMenu(_menuPeer, [this](const QString &text, base::lambda<void()> callback) {
return _menu->addAction(text, std::move(callback));
}, true);
connect(_menu, SIGNAL(destroyed(QObject*)), this, SLOT(onMenuDestroyed(QObject*)));

2
Telegram/SourceFiles/dialogswidget.h
View File

@ -112,7 +112,7 @@ public:
PeerData *updateFromParentDrag(QPoint globalPos);
void setLoadMoreCallback(base::lambda<void()> &&callback) {
void setLoadMoreCallback(base::lambda<void()> callback) {
_loadMoreCallback = std::move(callback);
}
void setVisibleTopBottom(int visibleTop, int visibleBottom) override;

2
Telegram/SourceFiles/facades.cpp
View File

@ -38,7 +38,7 @@ Q_DECLARE_METATYPE(Ui::ShowWay);
namespace App {
namespace internal {
void CallDelayed(int duration, base::lambda<void()> &&lambda) {
void CallDelayed(int duration, base::lambda_once<void()> &&lambda) {
QTimer::singleShot(duration, base::lambda_slot_once(App::app(), std::move(lambda)), SLOT(action()));
}

14
Telegram/SourceFiles/facades.h
View File

@ -35,12 +35,12 @@ class ItemBase;
namespace App {
namespace internal {
void CallDelayed(int duration, base::lambda<void()> &&lambda);
void CallDelayed(int duration, base::lambda_once<void()> &&lambda);
} // namespace internal
template <int N, typename Lambda>
inline void CallDelayed(int duration, base::internal::lambda_guard<N, Lambda> &&guarded) {
inline void CallDelayed(int duration, base::lambda_internal::guard<N, Lambda> &&guarded) {
return internal::CallDelayed(duration, [guarded = std::move(guarded)] { guarded(); });
}
@ -54,7 +54,15 @@ template <typename ...PointersAndLambda>
inline base::lambda<void()> LambdaDelayed(int duration, PointersAndLambda&&... qobjectsAndLambda) {
auto guarded = base::lambda_guarded(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
return [guarded = std::move(guarded), duration] {
CallDelayed(duration, guarded.clone());
internal::CallDelayed(duration, [guarded] { guarded(); });
};
}
template <typename ...PointersAndLambda>
inline base::lambda_once<void()> LambdaDelayedOnce(int duration, PointersAndLambda&&... qobjectsAndLambda) {
auto guarded = base::lambda_guarded(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
return [guarded = std::move(guarded), duration]() mutable {
internal::CallDelayed(duration, [guarded = std::move(guarded)] { guarded(); });
};
}

2
Telegram/SourceFiles/history/history_drag_area.h
View File

@ -37,7 +37,7 @@ public:
void hideFast();
void setDroppedCallback(base::lambda<void(const QMimeData *data)> &&callback) {
void setDroppedCallback(base::lambda<void(const QMimeData *data)> callback) {
_droppedCallback = std::move(callback);
}

4
Telegram/SourceFiles/intro/introwidget.cpp
View File

@ -722,11 +722,11 @@ void Widget::Step::showAnimated(Direction direction) {
}
}
void Widget::Step::setGoCallback(base::lambda<void(Step *step, Direction direction)> &&callback) {
void Widget::Step::setGoCallback(base::lambda<void(Step *step, Direction direction)> callback) {
_goCallback = std::move(callback);
}
void Widget::Step::setShowResetCallback(base::lambda<void()> &&callback) {
void Widget::Step::setShowResetCallback(base::lambda<void()> callback) {
_showResetCallback = std::move(callback);
}

4
Telegram/SourceFiles/intro/introwidget.h
View File

@ -100,8 +100,8 @@ public:
setFocus();
}
void setGoCallback(base::lambda<void(Step *step, Direction direction)> &&callback);
void setShowResetCallback(base::lambda<void()> &&callback);
void setGoCallback(base::lambda<void(Step *step, Direction direction)> callback);
void setShowResetCallback(base::lambda<void()> callback);
void prepareShowAnimated(Step *after);
void showAnimated(Direction direction);

2
Telegram/SourceFiles/layerwidget.cpp
View File

@ -45,7 +45,7 @@ public:
BackgroundWidget(QWidget *parent) : TWidget(parent) {
}
void setDoneCallback(base::lambda<void()> &&callback) {
void setDoneCallback(base::lambda<void()> callback) {
_doneCallback = std::move(callback);
}

4
Telegram/SourceFiles/layerwidget.h
View File

@ -45,10 +45,10 @@ public:
bool overlaps(const QRect &globalRect);
void setClosedCallback(base::lambda<void()> &&callback) {
void setClosedCallback(base::lambda<void()> callback) {
_closedCallback = std::move(callback);
}
void setResizedCallback(base::lambda<void()> &&callback) {
void setResizedCallback(base::lambda<void()> callback) {
_resizedCallback = std::move(callback);
}

2
Telegram/SourceFiles/mainwidget.cpp
View File

@ -1970,7 +1970,7 @@ void MainWidget::scheduleViewIncrement(HistoryItem *item) {
j.value().insert(item->id, true);
}
void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> &&handler)> &&callback, bool pinToggle) {
void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> handler)> callback, bool pinToggle) {
if (pinToggle) {
auto isPinned = false;
if (auto history = App::historyLoaded(peer)) {

2
Telegram/SourceFiles/mainwidget.h
View File

@ -367,7 +367,7 @@ public:
void scheduleViewIncrement(HistoryItem *item);
void fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> &&handler)> &&callback, bool pinToggle);
void fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> handler)> callback, bool pinToggle);
void gotRangeDifference(ChannelData *channel, const MTPupdates_ChannelDifference &diff);
void onSelfParticipantUpdated(ChannelData *channel);

2
Telegram/SourceFiles/media/player/media_player_button.cpp
View File

@ -45,7 +45,7 @@ QPainterPath interpolatePaths(QPointF (&from)[N], QPointF (&to)[N], float64 k) {
} // namespace
PlayButtonLayout::PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> &&callback)
PlayButtonLayout::PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> callback)
: _st(st)
, _callback(std::move(callback)) {
}

2
Telegram/SourceFiles/media/player/media_player_button.h
View File

@ -33,7 +33,7 @@ public:
Pause,
Cancel,
};
PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> &&callback);
PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> callback);
void setState(State state);
void finishTransform();

2
Telegram/SourceFiles/media/player/media_player_panel.h
View File

@ -48,7 +48,7 @@ public:
void showFromOther();
void hideFromOther();
using ButtonCallback = base::lambda_copy<void()>;
using ButtonCallback = base::lambda<void()>;
void setPinCallback(ButtonCallback &&callback);
void setCloseCallback(ButtonCallback &&callback);

17
Telegram/SourceFiles/mediaview.cpp
View File

@ -1446,24 +1446,15 @@ void MediaView::initThemePreview() {
}
update();
});
struct mutable_ready {
mutable_ready(decltype(ready) value) : value(std::move(value)) {
}
mutable decltype(ready) value;
};
struct mutable_result {
mutable_result(std::unique_ptr<Window::Theme::Preview> value) : value(std::move(value)) {
}
mutable std::unique_ptr<Window::Theme::Preview> value;
};
Window::Theme::CurrentData current;
current.backgroundId = Window::Theme::Background()->id();
current.backgroundImage = Window::Theme::Background()->pixmap();
current.backgroundTiled = Window::Theme::Background()->tile();
base::TaskQueue::Normal().Put([path, current, callback = mutable_ready(std::move(ready))]() {
base::TaskQueue::Normal().Put([ready = std::move(ready), path, current]() mutable {
auto preview = Window::Theme::GeneratePreview(path, current);
base::TaskQueue::Main().Put([result = mutable_result(std::move(preview)), callback = std::move(callback.value)]() {
callback(std::move(result.value));
base::TaskQueue::Main().Put([ready = std::move(ready), result = std::move(preview)]() mutable {
ready(std::move(result));
});
});
location.accessDisable();

12
Telegram/SourceFiles/mtproto/mtp_instance.cpp
View File

@ -87,8 +87,8 @@ public:
void setUpdatesHandler(RPCDoneHandlerPtr onDone);
void setGlobalFailHandler(RPCFailHandlerPtr onFail);
void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler);
void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler);
void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler);
void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler);
void clearGlobalHandlers();
internal::Session *getSession(ShiftedDcId shiftedDcId);
@ -1173,11 +1173,11 @@ void Instance::Private::setGlobalFailHandler(RPCFailHandlerPtr onFail) {
_globalHandler.onFail = onFail;
}
void Instance::Private::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler) {
void Instance::Private::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler) {
_stateChangedHandler = std::move(handler);
}
void Instance::Private::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler) {
void Instance::Private::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler) {
_sessionResetHandler = std::move(handler);
}
@ -1298,11 +1298,11 @@ void Instance::setGlobalFailHandler(RPCFailHandlerPtr onFail) {
_private->setGlobalFailHandler(onFail);
}
void Instance::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler) {
void Instance::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler) {
_private->setStateChangedHandler(std::move(handler));
}
void Instance::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler) {
void Instance::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler) {
_private->setSessionResetHandler(std::move(handler));
}

4
Telegram/SourceFiles/mtproto/mtp_instance.h
View File

@ -97,8 +97,8 @@ public:
void setUpdatesHandler(RPCDoneHandlerPtr onDone);
void setGlobalFailHandler(RPCFailHandlerPtr onFail);
void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler);
void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler);
void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler);
void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler);
void clearGlobalHandlers();
void onStateChange(ShiftedDcId dcWithShift, int32 state);

30
Telegram/SourceFiles/mtproto/rpc_sender.h
View File

@ -834,7 +834,7 @@ protected:
using Parent = RPCHandlerImplementation<Base, FunctionType>;
public:
RPCHandlerImplementation(Lambda &&handler) : _handler(std::move(handler)) {
RPCHandlerImplementation(Lambda handler) : _handler(std::move(handler)) {
}
protected:
@ -906,37 +906,37 @@ public:
};
template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*)> &&lambda) {
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBare<R>(std::move(lambda)));
}
template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*, mtpRequestId)> &&lambda) {
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*, mtpRequestId)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBareReq<R>(std::move(lambda)));
}
template <typename R, typename T>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&)> &&lambda) {
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationPlain<R, T>(std::move(lambda)));
}
template <typename R, typename T>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&, mtpRequestId)> &&lambda) {
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&, mtpRequestId)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationReq<R, T>(std::move(lambda)));
}
template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R()> &&lambda) {
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R()> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNo<R>(std::move(lambda)));
}
template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(mtpRequestId)> &&lambda) {
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(mtpRequestId)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNoReq<R>(std::move(lambda)));
}
template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>>
RPCDoneHandlerPtr rpcDone(Lambda &&lambda) {
template <typename Lambda>
RPCDoneHandlerPtr rpcDone(Lambda lambda) {
return rpcDone_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda)));
}
@ -979,23 +979,23 @@ public:
};
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&)> &&lambda) {
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&)> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationPlain(std::move(lambda)));
}
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&, mtpRequestId)> &&lambda) {
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&, mtpRequestId)> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationReq(std::move(lambda)));
}
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool()> &&lambda) {
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool()> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationNo(std::move(lambda)));
}
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(mtpRequestId)> &&lambda) {
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(mtpRequestId)> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationNoReq(std::move(lambda)));
}
template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>>
RPCFailHandlerPtr rpcFail(Lambda &&lambda) {
template <typename Lambda>
RPCFailHandlerPtr rpcFail(Lambda lambda) {
return rpcFail_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda)));
}

2
Telegram/SourceFiles/overview/overview_layout.cpp
View File

@ -156,7 +156,7 @@ public:
private:
void startAnimation();
base::lambda_copy<void()> _updateCallback;
base::lambda<void()> _updateCallback;
Ui::RoundCheckbox _check;
Animation _pression;

8
Telegram/SourceFiles/profile/profile_block_peer_list.h
View File

@ -81,16 +81,16 @@ public:
qSort(_items.begin(), _items.end(), std::move(predicate));
}
void setPreloadMoreCallback(base::lambda<void()> &&callback) {
void setPreloadMoreCallback(base::lambda<void()> callback) {
_preloadMoreCallback = std::move(callback);
}
void setSelectedCallback(base::lambda<void(PeerData*)> &&callback) {
void setSelectedCallback(base::lambda<void(PeerData*)> callback) {
_selectedCallback = std::move(callback);
}
void setRemovedCallback(base::lambda<void(PeerData*)> &&callback) {
void setRemovedCallback(base::lambda<void(PeerData*)> callback) {
_removedCallback = std::move(callback);
}
void setUpdateItemCallback(base::lambda<void(Item*)> &&callback) {
void setUpdateItemCallback(base::lambda<void(Item*)> callback) {
_updateItemCallback = std::move(callback);
}

2
Telegram/SourceFiles/settings/settings_layer.cpp
View File

@ -54,7 +54,7 @@ Layer::Layer()
connect(_scroll, SIGNAL(scrolled()), this, SLOT(onScroll()));
}
void Layer::setCloseClickHandler(base::lambda<void()> &&callback) {
void Layer::setCloseClickHandler(base::lambda<void()> callback) {
_fixedBarClose->setClickedCallback(std::move(callback));
}

2
Telegram/SourceFiles/settings/settings_layer.h
View File

@ -51,7 +51,7 @@ class Layer : public LayerWidget {
public:
Layer();
void setCloseClickHandler(base::lambda<void()> &&callback);
void setCloseClickHandler(base::lambda<void()> callback);
void resizeToWidth(int newWidth, int newContentLeft);
protected:

2
Telegram/SourceFiles/settings/settings_widget.cpp
View File

@ -43,7 +43,7 @@ namespace Settings {
namespace {
QString SecretText;
QMap<QString, base::lambda_copy<void()>> Codes;
QMap<QString, base::lambda<void()>> Codes;
void fillCodes() {
Codes.insert(qsl("debugmode"), []() {

2
Telegram/SourceFiles/ui/abstract_button.h
View File

@ -52,7 +52,7 @@ public:
void setAcceptBoth(bool acceptBoth = true);
void setClickedCallback(base::lambda<void()> &&callback) {
void setClickedCallback(base::lambda<void()> callback) {
_clickedCallback = std::move(callback);
}

15
Telegram/SourceFiles/ui/animation.h
View File

@ -88,7 +88,7 @@ enum Notification {
namespace anim {
using transition = base::lambda_copy<float64(float64 delta, float64 dt)>;
using transition = base::lambda<float64(float64 delta, float64 dt)>;
extern transition linear;
extern transition sineInOut;
@ -141,7 +141,7 @@ public:
_from += delta;
_cur += delta;
}
value &update(float64 dt, const transition &func) {
value &update(float64 dt, transition func) {
_cur = _from + func(_delta, dt);
return *this;
}
@ -590,7 +590,7 @@ public:
static constexpr auto kLongAnimationDuration = 1000;
template <typename Lambda>
void start(Lambda &&updateCallback, float64 from, float64 to, float64 duration, const anim::transition &transition = anim::linear) {
void start(Lambda &&updateCallback, float64 from, float64 to, float64 duration, anim::transition transition = anim::linear) {
auto isLong = (duration >= kLongAnimationDuration);
if (_data) {
if (!isLong) {
@ -618,17 +618,12 @@ public:
private:
struct Data {
template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>>
Data(float64 from, Lambda &&updateCallback)
template <typename Lambda>
Data(float64 from, Lambda updateCallback)
: value(from, from)
, a_animation(animation(this, &Data::step))
, updateCallback(std::move(updateCallback)) {
}
Data(float64 from, const base::lambda_copy<void()> &updateCallback)
: value(from, from)
, a_animation(animation(this, &Data::step))
, updateCallback(base::lambda_copy<void()>(updateCallback)) {
}
void step(float64 ms, bool timer) {
auto dt = (ms >= duration) ? 1. : (ms / duration);
if (dt >= 1) {

8
Telegram/SourceFiles/ui/buttons/history_down_button.h
View File

@ -92,16 +92,16 @@ public:
void setRecordActive(bool recordActive);
void finishAnimation();
void setRecordStartCallback(base::lambda<void()> &&callback) {
void setRecordStartCallback(base::lambda<void()> callback) {
_recordStartCallback = std::move(callback);
}
void setRecordUpdateCallback(base::lambda<void(QPoint globalPos)> &&callback) {
void setRecordUpdateCallback(base::lambda<void(QPoint globalPos)> callback) {
_recordUpdateCallback = std::move(callback);
}
void setRecordStopCallback(base::lambda<void(bool active)> &&callback) {
void setRecordStopCallback(base::lambda<void(bool active)> callback) {
_recordStopCallback = std::move(callback);
}
void setRecordAnimationCallback(base::lambda<void()> &&callback) {
void setRecordAnimationCallback(base::lambda<void()> callback) {
_recordAnimationCallback = std::move(callback);
}

2
Telegram/SourceFiles/ui/effects/ripple_animation.cpp
View File

@ -195,7 +195,7 @@ void RippleAnimation::paint(QPainter &p, int x, int y, int outerWidth, TimeMs ms
clearFinished();
}
QImage RippleAnimation::maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> &&drawer) {
QImage RippleAnimation::maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> drawer) {
auto result = QImage(size * cIntRetinaFactor(), QImage::Format_ARGB32_Premultiplied);
result.setDevicePixelRatio(cRetinaFactor());
result.fill(filled ? QColor(255, 255, 255) : Qt::transparent);

4
Telegram/SourceFiles/ui/effects/ripple_animation.h
View File

@ -26,7 +26,7 @@ namespace Ui {
class RippleAnimation {
public:
using UpdateCallback = base::lambda_copy<void()>;
using UpdateCallback = base::lambda<void()>;
// White upon transparent mask, like colorizeImage(black-white-mask, white).
RippleAnimation(const style::RippleAnimation &st, QImage mask, const UpdateCallback &update);
@ -43,7 +43,7 @@ public:
return _ripples.isEmpty();
}
static QImage maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> &&drawer);
static QImage maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> drawer);
static QImage rectMask(QSize size);
static QImage roundRectMask(QSize size, int radius);
static QImage ellipseMask(QSize size);

4
Telegram/SourceFiles/ui/effects/round_checkbox.cpp
View File

@ -59,7 +59,7 @@ void prepareCheckCaches(const style::RoundCheckbox *st, bool displayInactive, QP
} // namespace
RoundCheckbox::RoundCheckbox(const style::RoundCheckbox &st, const base::lambda_copy<void()> &updateCallback)
RoundCheckbox::RoundCheckbox(const style::RoundCheckbox &st, base::lambda<void()> updateCallback)
: _st(st)
, _updateCallback(updateCallback) {
}
@ -232,7 +232,7 @@ void RoundCheckbox::prepareInactiveCache() {
_inactiveCacheFg = App::pixmapFromImageInPlace(std::move(cacheFg));
}
RoundImageCheckbox::RoundImageCheckbox(const style::RoundImageCheckbox &st, const base::lambda_copy<void()> &updateCallback, PaintRoundImage &&paintRoundImage)
RoundImageCheckbox::RoundImageCheckbox(const style::RoundImageCheckbox &st, base::lambda<void()> updateCallback, PaintRoundImage &&paintRoundImage)
: _st(st)
, _updateCallback(updateCallback)
, _paintRoundImage(std::move(paintRoundImage))

8
Telegram/SourceFiles/ui/effects/round_checkbox.h
View File

@ -26,7 +26,7 @@ namespace Ui {
class RoundCheckbox {
public:
RoundCheckbox(const style::RoundCheckbox &st, const base::lambda_copy<void()> &updateCallback);
RoundCheckbox(const style::RoundCheckbox &st, base::lambda<void()> updateCallback);
void paint(Painter &p, TimeMs ms, int x, int y, int outerWidth, float64 masterScale = 1.);
@ -54,7 +54,7 @@ private:
QRect cacheDestRect(int x, int y, float64 scale) const;
const style::RoundCheckbox &_st;
base::lambda_copy<void()> _updateCallback;
base::lambda<void()> _updateCallback;
bool _checked = false;
std::vector<Icon> _icons;
@ -70,7 +70,7 @@ private:
class RoundImageCheckbox {
public:
using PaintRoundImage = base::lambda<void(Painter &p, int x, int y, int outerWidth, int size)>;
RoundImageCheckbox(const style::RoundImageCheckbox &st, const base::lambda_copy<void()> &updateCallback, PaintRoundImage &&paintRoundImage);
RoundImageCheckbox(const style::RoundImageCheckbox &st, base::lambda<void()> updateCallback, PaintRoundImage &&paintRoundImage);
void paint(Painter &p, TimeMs ms, int x, int y, int outerWidth);
float64 checkedAnimationRatio() const;
@ -89,7 +89,7 @@ private:
void prepareWideCache();
const style::RoundImageCheckbox &_st;
base::lambda_copy<void()> _updateCallback;
base::lambda<void()> _updateCallback;
PaintRoundImage _paintRoundImage;
QPixmap _wideCache;

2
Telegram/SourceFiles/ui/effects/widget_fade_wrap.cpp
View File

@ -120,7 +120,7 @@ void FadeAnimation::updateCallback() {
WidgetFadeWrap<TWidget>::WidgetFadeWrap(QWidget *parent
, object_ptr<TWidget> entity
, int duration
, base::lambda<void()> &&updateCallback) : TWidget(parent)
, base::lambda<void()> updateCallback) : TWidget(parent)
, _entity(std::move(entity))
, _duration(duration)
, _updateCallback(std::move(updateCallback))

4
Telegram/SourceFiles/ui/effects/widget_fade_wrap.h
View File

@ -78,7 +78,7 @@ public:
WidgetFadeWrap(QWidget *parent
, object_ptr<TWidget> entity
, int duration = st::widgetFadeDuration
, base::lambda<void()> &&updateCallback = base::lambda<void()>());
, base::lambda<void()> updateCallback = base::lambda<void()>());
void showAnimated() {
_animation.fadeIn(_duration);
@ -140,7 +140,7 @@ public:
WidgetFadeWrap(QWidget *parent
, object_ptr<Widget> entity
, int duration = st::widgetFadeDuration
, base::lambda<void()> &&updateCallback = base::lambda<void()>()) : WidgetFadeWrap<TWidget>(parent
, base::lambda<void()> updateCallback = base::lambda<void()>()) : WidgetFadeWrap<TWidget>(parent
, std::move(entity)
, duration
, std::move(updateCallback)) {

2
Telegram/SourceFiles/ui/effects/widget_slide_wrap.cpp
View File

@ -26,7 +26,7 @@ namespace Ui {
WidgetSlideWrap<TWidget>::WidgetSlideWrap(QWidget *parent
, object_ptr<TWidget> entity
, style::margins entityPadding
, base::lambda<void()> &&updateCallback
, base::lambda<void()> updateCallback
, int duration) : TWidget(parent)
, _entity(std::move(entity))
, _padding(entityPadding)

4
Telegram/SourceFiles/ui/effects/widget_slide_wrap.h
View File

@ -33,7 +33,7 @@ public:
WidgetSlideWrap(QWidget *parent
, object_ptr<TWidget> entity
, style::margins entityPadding
, base::lambda<void()> &&updateCallback
, base::lambda<void()> updateCallback
, int duration = st::widgetSlideDuration);
void slideUp();
@ -78,7 +78,7 @@ public:
WidgetSlideWrap(QWidget *parent
, object_ptr<Widget> entity
, style::margins entityPadding
, base::lambda<void()> &&updateCallback
, base::lambda<void()> updateCallback
, int duration = st::widgetSlideDuration) : WidgetSlideWrap<TWidget>(parent
, std::move(entity)
, entityPadding

8
Telegram/SourceFiles/ui/filedialog.cpp
View File

@ -394,7 +394,7 @@ base::Observable<QueryUpdate> &QueryDone() {
return QueryDoneObservable;
}
void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed) {
void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, filter, callback = std::move(callback), failed = std::move(failed)] {
auto file = QString();
auto remoteContent = QByteArray();
@ -413,7 +413,7 @@ void askOpenPath(const QString &caption, const QString &filter, base::lambda<voi
});
}
void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed) {
void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, filter, callback = std::move(callback), failed = std::move(failed)] {
auto files = QStringList();
auto remoteContent = QByteArray();
@ -431,7 +431,7 @@ void askOpenPaths(const QString &caption, const QString &filter, base::lambda<vo
}
void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed) {
void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, filter, initialPath, callback = std::move(callback), failed = std::move(failed)] {
auto file = QString();
if (filedialogGetSaveFile(file, caption, filter, initialPath)) {
@ -444,7 +444,7 @@ void askWritePath(const QString &caption, const QString &filter, const QString &
});
}
void askFolder(const QString &caption, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed) {
void askFolder(const QString &caption, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, callback = std::move(callback), failed = std::move(failed)] {
auto folder = QString();
if (filedialogGetDir(folder, caption) && !folder.isEmpty()) {

8
Telegram/SourceFiles/ui/filedialog.h
View File

@ -69,9 +69,9 @@ struct OpenResult {
QStringList paths;
QByteArray remoteContent;
};
void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>());
void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>());
void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>());
void askFolder(const QString &caption, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>());
void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
void askFolder(const QString &caption, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
} // namespace FileDialog

8
Telegram/SourceFiles/ui/widgets/buttons.cpp
View File

@ -192,9 +192,9 @@ void FlatButton::paintEvent(QPaintEvent *e) {
class RoundButton::Numbers {
public:
Numbers(const style::RoundButton &st, base::lambda<void()> &&animationCallback);
Numbers(const style::RoundButton &st, base::lambda<void()> animationCallback);
void setWidthChangedCallback(base::lambda<void()> &&callback) {
void setWidthChangedCallback(base::lambda<void()> callback) {
_widthChangedCallback = std::move(callback);
}
void setText(const QString &text, int value);
@ -235,7 +235,7 @@ private:
};
RoundButton::Numbers::Numbers(const style::RoundButton &st, base::lambda<void()> &&animationCallback)
RoundButton::Numbers::Numbers(const style::RoundButton &st, base::lambda<void()> animationCallback)
: _st(st)
, _animationCallback(std::move(animationCallback)) {
for (auto ch = '0'; ch != '9'; ++ch) {
@ -380,7 +380,7 @@ void RoundButton::setNumbersText(const QString &numbersText, int numbers) {
updateText();
}
void RoundButton::setWidthChangedCallback(base::lambda<void()> &&callback) {
void RoundButton::setWidthChangedCallback(base::lambda<void()> callback) {
if (!_numbers) {
_numbers = std::make_unique<Numbers>(_st, [this] { numbersAnimationCallback(); });
}

2
Telegram/SourceFiles/ui/widgets/buttons.h
View File

@ -121,7 +121,7 @@ public:
void setNumbersText(int numbers) {
setNumbersText(QString::number(numbers), numbers);
}
void setWidthChangedCallback(base::lambda<void()> &&callback);
void setWidthChangedCallback(base::lambda<void()> callback);
void stepNumbersAnimation(TimeMs ms);
void finishNumbersAnimation();

2
Telegram/SourceFiles/ui/widgets/dropdown_menu.cpp
View File

@ -69,7 +69,7 @@ QAction *DropdownMenu::addAction(const QString &text, const QObject *receiver, c
return _menu->addAction(text, receiver, member, icon, iconOver);
}
QAction *DropdownMenu::addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon, const style::icon *iconOver) {
QAction *DropdownMenu::addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon, const style::icon *iconOver) {
return _menu->addAction(text, std::move(callback), icon, iconOver);
}

4
Telegram/SourceFiles/ui/widgets/dropdown_menu.h
View File

@ -30,11 +30,11 @@ public:
DropdownMenu(QWidget *parent, const style::DropdownMenu &st = st::defaultDropdownMenu);
QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addSeparator();
void clearActions();
void setHiddenCallback(base::lambda<void()> &&callback) {
void setHiddenCallback(base::lambda<void()> callback) {
_hiddenCallback = std::move(callback);
}

6
Telegram/SourceFiles/ui/widgets/inner_dropdown.h
View File

@ -48,13 +48,13 @@ public:
void otherLeave();
void hideFast();
void setShowStartCallback(base::lambda<void()> &&callback) {
void setShowStartCallback(base::lambda<void()> callback) {
_showStartCallback = std::move(callback);
}
void setHideStartCallback(base::lambda<void()> &&callback) {
void setHideStartCallback(base::lambda<void()> callback) {
_hideStartCallback = std::move(callback);
}
void setHiddenCallback(base::lambda<void()> &&callback) {
void setHiddenCallback(base::lambda<void()> callback) {
_hiddenCallback = std::move(callback);
}

2
Telegram/SourceFiles/ui/widgets/menu.cpp
View File

@ -57,7 +57,7 @@ QAction *Menu::addAction(const QString &text, const QObject *receiver, const cha
return action;
}
QAction *Menu::addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon, const style::icon *iconOver) {
QAction *Menu::addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon, const style::icon *iconOver) {
auto action = addAction(new QAction(text, this), icon, iconOver);
connect(action, SIGNAL(triggered(bool)), base::lambda_slot(action, std::move(callback)), SLOT(action()), Qt::QueuedConnection);
return action;

16
Telegram/SourceFiles/ui/widgets/menu.h
View File

@ -34,7 +34,7 @@ public:
Menu(QWidget *parent, QMenu *menu, const style::Menu &st = st::defaultMenu);
QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addSeparator();
void clearActions();
@ -52,33 +52,33 @@ public:
using Actions = QList<QAction*>;
Actions &actions();
void setResizedCallback(base::lambda<void()> &&callback) {
void setResizedCallback(base::lambda<void()> callback) {
_resizedCallback = std::move(callback);
}
void setActivatedCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> &&callback) {
void setActivatedCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> callback) {
_activatedCallback = std::move(callback);
}
void setTriggeredCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> &&callback) {
void setTriggeredCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> callback) {
_triggeredCallback = std::move(callback);
}
void setKeyPressDelegate(base::lambda<bool(int key)> &&delegate) {
void setKeyPressDelegate(base::lambda<bool(int key)> delegate) {
_keyPressDelegate = std::move(delegate);
}
void handleKeyPress(int key);
void setMouseMoveDelegate(base::lambda<void(QPoint globalPosition)> &&delegate) {
void setMouseMoveDelegate(base::lambda<void(QPoint globalPosition)> delegate) {
_mouseMoveDelegate = std::move(delegate);
}
void handleMouseMove(QPoint globalPosition);
void setMousePressDelegate(base::lambda<void(QPoint globalPosition)> &&delegate) {
void setMousePressDelegate(base::lambda<void(QPoint globalPosition)> delegate) {
_mousePressDelegate = std::move(delegate);
}
void handleMousePress(QPoint globalPosition);
void setMouseReleaseDelegate(base::lambda<void(QPoint globalPosition)> &&delegate) {
void setMouseReleaseDelegate(base::lambda<void(QPoint globalPosition)> delegate) {
_mouseReleaseDelegate = std::move(delegate);
}
void handleMouseRelease(QPoint globalPosition);

26
Telegram/SourceFiles/ui/widgets/multi_select.cpp
View File

@ -57,7 +57,7 @@ public:
void setPosition(int x, int y, int outerWidth, int maxVisiblePadding);
QRect paintArea(int outerWidth) const;
void setUpdateCallback(const base::lambda_copy<void()> &updateCallback) {
void setUpdateCallback(base::lambda<void()> updateCallback) {
_updateCallback = updateCallback;
}
void setText(const QString &text);
@ -89,7 +89,7 @@ private:
uint64 _id;
struct SlideAnimation {
SlideAnimation(const base::lambda_copy<void()> &updateCallback, int fromX, int toX, int y, float64 duration)
SlideAnimation(base::lambda<void()> updateCallback, int fromX, int toX, int y, float64 duration)
: fromX(fromX)
, toX(toX)
, y(y) {
@ -112,7 +112,7 @@ private:
bool _overDelete = false;
bool _active = false;
PaintRoundImage _paintRoundImage;
base::lambda_copy<void()> _updateCallback;
base::lambda<void()> _updateCallback;
bool _hiding = false;
};
@ -376,15 +376,15 @@ void MultiSelect::scrollTo(int activeTop, int activeBottom) {
}
}
void MultiSelect::setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback) {
void MultiSelect::setQueryChangedCallback(base::lambda<void(const QString &query)> callback) {
_queryChangedCallback = std::move(callback);
}
void MultiSelect::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback) {
void MultiSelect::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback) {
_inner->setSubmittedCallback(std::move(callback));
}
void MultiSelect::setResizedCallback(base::lambda<void()> &&callback) {
void MultiSelect::setResizedCallback(base::lambda<void()> callback) {
_resizedCallback = std::move(callback);
}
@ -402,11 +402,11 @@ QString MultiSelect::getQuery() const {
return _inner->getQuery();
}
void MultiSelect::addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage &&paintRoundImage, AddItemWay way) {
void MultiSelect::addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage paintRoundImage, AddItemWay way) {
_inner->addItem(std::make_unique<Inner::Item>(_st.item, itemId, text, color, std::move(paintRoundImage)), way);
}
void MultiSelect::setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback) {
void MultiSelect::setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback) {
_inner->setItemRemovedCallback(std::move(callback));
}
@ -423,7 +423,7 @@ int MultiSelect::resizeGetHeight(int newWidth) {
return newHeight;
}
MultiSelect::Inner::Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback &&callback) : TWidget(parent)
MultiSelect::Inner::Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback callback) : TWidget(parent)
, _st(st)
, _scrollCallback(std::move(callback))
, _field(this, _st.field, placeholder)
@ -470,11 +470,11 @@ void MultiSelect::Inner::clearQuery() {
_field->setText(QString());
}
void MultiSelect::Inner::setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback) {
void MultiSelect::Inner::setQueryChangedCallback(base::lambda<void(const QString &query)> callback) {
_queryChangedCallback = std::move(callback);
}
void MultiSelect::Inner::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback) {
void MultiSelect::Inner::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback) {
_submittedCallback = std::move(callback);
}
@ -775,11 +775,11 @@ void MultiSelect::Inner::setItemText(uint64 itemId, const QString &text) {
}
}
void MultiSelect::Inner::setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback) {
void MultiSelect::Inner::setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback) {
_itemRemovedCallback = std::move(callback);
}
void MultiSelect::Inner::setResizedCallback(base::lambda<void(int heightDelta)> &&callback) {
void MultiSelect::Inner::setResizedCallback(base::lambda<void(int heightDelta)> callback) {
_resizedCallback = std::move(callback);
}

20
Telegram/SourceFiles/ui/widgets/multi_select.h
View File

@ -36,19 +36,19 @@ public:
void setInnerFocus();
void clearQuery();
void setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback);
void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback);
void setResizedCallback(base::lambda<void()> &&callback);
void setQueryChangedCallback(base::lambda<void(const QString &query)> callback);
void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback);
void setResizedCallback(base::lambda<void()> callback);
enum class AddItemWay {
Default,
SkipAnimation,
};
using PaintRoundImage = base::lambda<void(Painter &p, int x, int y, int outerWidth, int size)>;
void addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage &&paintRoundImage, AddItemWay way = AddItemWay::Default);
void addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage paintRoundImage, AddItemWay way = AddItemWay::Default);
void setItemText(uint64 itemId, const QString &text);
void setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback);
void setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback);
void removeItem(uint64 itemId);
protected:
@ -76,23 +76,23 @@ class MultiSelect::Inner : public TWidget {
public:
using ScrollCallback = base::lambda<void(int activeTop, int activeBottom)>;
Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback &&callback);
Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback callback);
QString getQuery() const;
bool setInnerFocus();
void clearQuery();
void setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback);
void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback);
void setQueryChangedCallback(base::lambda<void(const QString &query)> callback);
void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback);
class Item;
void addItem(std::unique_ptr<Item> item, AddItemWay way);
void setItemText(uint64 itemId, const QString &text);
void setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback);
void setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback);
void removeItem(uint64 itemId);
void setResizedCallback(base::lambda<void(int heightDelta)> &&callback);
void setResizedCallback(base::lambda<void(int heightDelta)> callback);
~Inner();

2
Telegram/SourceFiles/ui/widgets/popup_menu.cpp
View File

@ -86,7 +86,7 @@ QAction *PopupMenu::addAction(const QString &text, const QObject *receiver, cons
return _menu->addAction(text, receiver, member, icon, iconOver);
}
QAction *PopupMenu::addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon, const style::icon *iconOver) {
QAction *PopupMenu::addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon, const style::icon *iconOver) {
return _menu->addAction(text, std::move(callback), icon, iconOver);
}

4
Telegram/SourceFiles/ui/widgets/popup_menu.h
View File

@ -29,7 +29,7 @@ public:
PopupMenu(QWidget*, QMenu *menu, const style::PopupMenu &st = st::defaultPopupMenu);
QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addSeparator();
void clearActions();
@ -40,7 +40,7 @@ public:
void popup(const QPoint &p);
void hideMenu(bool fast = false);
void setDestroyedCallback(base::lambda<void()> &&callback) {
void setDestroyedCallback(base::lambda<void()> callback) {
_destroyedCallback = std::move(callback);
}

2
Telegram/SourceFiles/window/player_wrap_widget.cpp
View File

@ -25,7 +25,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
namespace Window {
PlayerWrapWidget::PlayerWrapWidget(QWidget *parent, base::lambda<void()> &&updateCallback) : Parent(parent
PlayerWrapWidget::PlayerWrapWidget(QWidget *parent, base::lambda<void()> updateCallback) : Parent(parent
, object_ptr<Media::Player::Widget>(parent)
, style::margins(0, 0, 0, 0)
, std::move(updateCallback)) {

2
Telegram/SourceFiles/window/player_wrap_widget.h
View File

@ -13,7 +13,7 @@ class PlayerWrapWidget : public Ui::WidgetSlideWrap<Media::Player::Widget> {
using Parent = Ui::WidgetSlideWrap<Media::Player::Widget>;
public:
PlayerWrapWidget(QWidget *parent, base::lambda<void()> &&updateCallback);
PlayerWrapWidget(QWidget *parent, base::lambda<void()> updateCallback);
void updateAdaptiveLayout() {
updateShadowGeometry();

2
Telegram/SourceFiles/window/themes/window_theme.cpp
View File

@ -798,7 +798,7 @@ bool CopyColorsToPalette(const QString &path, const QByteArray &themeContent) {
return true;
}
bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> &&callback) {
bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> callback) {
if (content.size() > kThemeSchemeSizeLimit) {
LOG(("Theme Error: color scheme file too large (should be less than 1 MB, got %2)").arg(content.size()));
return false;

2
Telegram/SourceFiles/window/themes/window_theme.h
View File

@ -141,7 +141,7 @@ void ComputeBackgroundRects(QRect wholeFill, QSize imageSize, QRect &to, QRect &
bool CopyColorsToPalette(const QString &path, const QByteArray &themeContent);
bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> &&callback);
bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> callback);
} // namespace Theme
} // namespace Window

6
Telegram/SourceFiles/window/themes/window_theme_editor.cpp
View File

@ -208,13 +208,13 @@ class Editor::Inner : public TWidget, private base::Subscriber {
public:
Inner(QWidget *parent, const QString &path);
void setErrorCallback(base::lambda<void()> &&callback) {
void setErrorCallback(base::lambda<void()> callback) {
_errorCallback = std::move(callback);
}
void setFocusCallback(base::lambda<void()> &&callback) {
void setFocusCallback(base::lambda<void()> callback) {
_focusCallback = std::move(callback);
}
void setScrollCallback(base::lambda<void(int top, int bottom)> &&callback) {
void setScrollCallback(base::lambda<void(int top, int bottom)> callback) {
_scrollCallback = std::move(callback);
}

2
Telegram/SourceFiles/window/themes/window_theme_warning.h
View File

@ -31,7 +31,7 @@ class WarningWidget : public TWidget {
public:
WarningWidget(QWidget *parent);
void setHiddenCallback(base::lambda<void()> &&callback) {
void setHiddenCallback(base::lambda<void()> callback) {
_hiddenCallback = std::move(callback);
}

2
Telegram/SourceFiles/window/top_bar_widget.cpp
View File

@ -126,7 +126,7 @@ void TopBarWidget::showMenu() {
}
}));
_menuToggle->installEventFilter(_menu);
App::main()->fillPeerMenu(peer, [this](const QString &text, base::lambda<void()> &&callback) {
App::main()->fillPeerMenu(peer, [this](const QString &text, base::lambda<void()> callback) {
return _menu->addAction(text, std::move(callback));
}, false);
_menu->moveToRight(st::topBarMenuPosition.x(), st::topBarMenuPosition.y());