Using standard library instead of std_ namespace.

Currently tested only in VS2015.

Telegram/SourceFiles/app.cpp

@@ -2186,7 +2186,7 @@ namespace {
 		cors[3] = rect.copy(r * 2, r * 2, r, r + (shadow ? s : 0));
 		if (index != SmallMaskCorners && index != LargeMaskCorners) {
 			for (int i = 0; i < 4; ++i) {
-				::corners[index].p[i] = new QPixmap(pixmapFromImageInPlace(std_::move(cors[i])));
+				::corners[index].p[i] = new QPixmap(pixmapFromImageInPlace(std::move(cors[i])));
 				::corners[index].p[i]->setDevicePixelRatio(cRetinaFactor());
 			}
 		}
@@ -2424,7 +2424,7 @@ namespace {
 				QPainter p(&image);
 				emojiDraw(p, emoji, st::emojiPadding * cIntRetinaFactor(), (fontHeight * cIntRetinaFactor() - Ui::Emoji::Size()) / 2);
 			}
-			i = map.insert(emoji->index(), App::pixmapFromImageInPlace(std_::move(image)));
+			i = map.insert(emoji->index(), App::pixmapFromImageInPlace(std::move(image)));
 		}
 		return i.value();
 	}
@@ -2550,7 +2550,7 @@ namespace {
 			}
 #endif // OS_MAC_OLD
 		} else if (opaque) {
-			result = Images::prepareOpaque(std_::move(result));
+			result = Images::prepareOpaque(std::move(result));
 		}
 		return result;
 	}
@@ -2570,7 +2570,7 @@ namespace {
 	}
 
 	QPixmap pixmapFromImageInPlace(QImage &&image) {
-		return QPixmap::fromImage(std_::move(image), Qt::ColorOnly);
+		return QPixmap::fromImage(std::move(image), Qt::ColorOnly);
 	}
 
 	void regPhotoItem(PhotoData *data, HistoryItem *item) {
@@ -2860,7 +2860,7 @@ namespace {
 
 			CornersPixmaps pixmaps;
 			for (int j = 0; j < 4; ++j) {
-				pixmaps.p[j] = new QPixmap(pixmapFromImageInPlace(std_::move(images[j])));
+				pixmaps.p[j] = new QPixmap(pixmapFromImageInPlace(std::move(images[j])));
 				pixmaps.p[j]->setDevicePixelRatio(cRetinaFactor());
 			}
 			i = cornersMap.insert(colorKey, pixmaps);

Telegram/SourceFiles/boxes/abstractbox.cpp

@@ -34,15 +34,15 @@ BoxLayerTitleShadow::BoxLayerTitleShadow(QWidget *parent) : Ui::PlainShadow(pare
 }
 
 QPointer<Ui::RoundButton> BoxContent::addButton(const QString &text, base::lambda<void()> &&clickCallback) {
-	return addButton(text, std_::move(clickCallback), st::defaultBoxButton);
+	return addButton(text, std::move(clickCallback), st::defaultBoxButton);
 }
 
 QPointer<Ui::RoundButton> BoxContent::addLeftButton(const QString &text, base::lambda<void()> &&clickCallback) {
-	return getDelegate()->addLeftButton(text, std_::move(clickCallback), st::defaultBoxButton);
+	return getDelegate()->addLeftButton(text, std::move(clickCallback), st::defaultBoxButton);
 }
 
 void BoxContent::setInner(object_ptr<TWidget> inner) {
-	setInner(std_::move(inner), st::boxLayerScroll);
+	setInner(std::move(inner), st::boxLayerScroll);
 }
 
 void BoxContent::setInner(object_ptr<TWidget> inner, const style::ScrollArea &st) {
@@ -50,7 +50,7 @@ void BoxContent::setInner(object_ptr<TWidget> inner, const style::ScrollArea &st
 		getDelegate()->setLayerType(true);
 		_scroll.create(this, st);
 		_scroll->setGeometryToLeft(0, _innerTopSkip, width(), 0);
-		_scroll->setOwnedWidget(std_::move(inner));
+		_scroll->setOwnedWidget(std::move(inner));
 		if (_topShadow) {
 			_topShadow->raise();
 			_bottomShadow->raise();
@@ -155,7 +155,7 @@ QPixmap BoxContent::grabInnerCache() {
 	auto result = myGrab(this, _scroll->geometry());
 	if (isTopShadowVisible) _topShadow->show();
 	if (isBottomShadowVisible) _bottomShadow->show();
-	return std_::move(result);
+	return std::move(result);
 }
 
 void BoxContent::resizeEvent(QResizeEvent *e) {
@@ -197,14 +197,14 @@ void BoxContent::paintEvent(QPaintEvent *e) {
 	Painter p(this);
 
 	if (testAttribute(Qt::WA_OpaquePaintEvent)) {
-		for_const (auto rect, e->region().rects()) {
+		for (auto rect : e->region().rects()) {
 			p.fillRect(rect, st::boxBg);
 		}
 	}
 }
 
 AbstractBox::AbstractBox(QWidget *parent, object_ptr<BoxContent> content) : LayerWidget(parent)
-, _content(std_::move(content)) {
+, _content(std::move(content)) {
 	_content->setParent(this);
 	_content->setDelegate(this);
 }
@@ -240,7 +240,7 @@ void AbstractBox::paintEvent(QPaintEvent *e) {
 	}
 	auto other = e->region().intersected(QRect(0, st::boxRadius, width(), height() - 2 * st::boxRadius));
 	if (!other.isEmpty()) {
-		for_const (auto rect, other.rects()) {
+		for (auto rect : other.rects()) {
 			p.fillRect(rect, st::boxBg);
 		}
 	}
@@ -289,7 +289,7 @@ void AbstractBox::updateSize() {
 }
 
 void AbstractBox::updateButtonsPositions() {
-	if (!_buttons.isEmpty() || _leftButton) {
+	if (!_buttons.empty() || _leftButton) {
 		auto padding = _layerType ? st::boxLayerButtonPadding : st::boxButtonPadding;
 		auto right = padding.right();
 		auto top = buttonsTop();
@@ -313,7 +313,7 @@ void AbstractBox::clearButtons() {
 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));
+	result->setClickedCallback(std::move(clickCallback));
 	result->show();
 	updateButtonsPositions();
 	return result;
@@ -322,7 +322,7 @@ QPointer<Ui::RoundButton> AbstractBox::addButton(const QString &text, base::lamb
 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));
+	result->setClickedCallback(std::move(clickCallback));
 	result->show();
 	updateButtonsPositions();
 	return result;

Telegram/SourceFiles/boxes/abstractbox.h

@@ -101,7 +101,7 @@ protected:
 	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);
+		return getDelegate()->addButton(text, std::move(clickCallback), st);
 	}
 	void updateButtonsGeometry() {
 		getDelegate()->updateButtonsPositions();
@@ -123,7 +123,7 @@ protected:
 	QPointer<Widget> setInnerWidget(object_ptr<Widget> inner, const style::ScrollArea &st, int topSkip = 0) {
 		auto result = QPointer<Widget>(inner.data());
 		setInnerTopSkip(topSkip);
-		setInner(std_::move(inner), st);
+		setInner(std::move(inner), st);
 		return result;
 	}
 
@@ -131,7 +131,7 @@ protected:
 	QPointer<Widget> setInnerWidget(object_ptr<Widget> inner, int topSkip = 0) {
 		auto result = QPointer<Widget>(inner.data());
 		setInnerTopSkip(topSkip);
-		setInner(std_::move(inner));
+		setInner(std::move(inner));
 		return result;
 	}
 
@@ -241,7 +241,7 @@ private:
 	QString _additionalTitle;
 	bool _layerType = false;
 
-	std_::vector_of_moveable<object_ptr<Ui::RoundButton>> _buttons;
+	std::vector<object_ptr<Ui::RoundButton>> _buttons;
 	object_ptr<Ui::RoundButton> _leftButton = { nullptr };
 
 };

Telegram/SourceFiles/boxes/addcontactbox.cpp

@@ -1115,7 +1115,7 @@ RevokePublicLinkBox::RevokePublicLinkBox(QWidget*, base::lambda<void()> &&revoke
 : _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)
-, _revokeCallback(std_::move(revokeCallback)) {
+, _revokeCallback(std::move(revokeCallback)) {
 }
 
 void RevokePublicLinkBox::prepare() {
@@ -1231,7 +1231,7 @@ void RevokePublicLinkBox::getPublicDone(const MTPmessages_Chats &result) {
 				row.peer = peer;
 				row.name.setText(st::contactsNameStyle, peer->name, _textNameOptions);
 				row.status.setText(st::defaultTextStyle, CreateInternalLink(textcmdLink(1, peer->userName())), _textDlgOptions);
-				_rows.push_back(std_::move(row));
+				_rows.push_back(std::move(row));
 			}
 		}
 	}

Telegram/SourceFiles/boxes/backgroundbox.cpp

@@ -55,7 +55,7 @@ void BackgroundBox::backgroundChosen(int index) {
 }
 
 BackgroundBox::Inner::Inner(QWidget *parent) : TWidget(parent)
-, _check(std_::make_unique<Ui::RoundCheckbox>(st::overviewCheck, [this] { update(); })) {
+, _check(std::make_unique<Ui::RoundCheckbox>(st::overviewCheck, [this] { update(); })) {
 	_check->setChecked(true, Ui::RoundCheckbox::SetStyle::Fast);
 	if (App::cServerBackgrounds().isEmpty()) {
 		resize(BackgroundsInRow * (st::backgroundSize.width() + st::backgroundPadding) + st::backgroundPadding, 2 * (st::backgroundSize.height() + st::backgroundPadding) + st::backgroundPadding);

Telegram/SourceFiles/boxes/backgroundbox.h

@@ -47,7 +47,7 @@ public:
 	Inner(QWidget *parent);
 
 	void setBackgroundChosenCallback(base::lambda<void(int index)> &&callback) {
-		_backgroundChosenCallback = std_::move(callback);
+		_backgroundChosenCallback = std::move(callback);
 	}
 
 	~Inner();
@@ -68,6 +68,6 @@ private:
 	int _rows = 0;
 	int _over = -1;
 	int _overDown = -1;
-	std_::unique_ptr<Ui::RoundCheckbox> _check; // this is not a widget
+	std::unique_ptr<Ui::RoundCheckbox> _check; // this is not a widget
 
 };

Telegram/SourceFiles/boxes/confirmbox.cpp

@@ -46,8 +46,8 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, base::lambda<void()> &&con
 , _cancelText(lang(lng_cancel))
 , _confirmStyle(st::defaultBoxButton)
 , _text(st::boxWidth - st::boxPadding.left() - st::boxButtonPadding.right())
-, _confirmedCallback(std_::move(confirmedCallback))
+, _confirmedCallback(std::move(confirmedCallback))
-, _cancelledCallback(std_::move(cancelledCallback)) {
+, _cancelledCallback(std::move(cancelledCallback)) {
 	init(text);
 }
 
@@ -56,8 +56,8 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
 , _cancelText(lang(lng_cancel))
 , _confirmStyle(st::defaultBoxButton)
 , _text(st::boxWidth - st::boxPadding.left() - st::boxButtonPadding.right())
-, _confirmedCallback(std_::move(confirmedCallback))
+, _confirmedCallback(std::move(confirmedCallback))
-, _cancelledCallback(std_::move(cancelledCallback)) {
+, _cancelledCallback(std::move(cancelledCallback)) {
 	init(text);
 }
 
@@ -66,8 +66,8 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
 , _cancelText(lang(lng_cancel))
 , _confirmStyle(confirmStyle)
 , _text(st::boxWidth - st::boxPadding.left() - st::boxButtonPadding.right())
-, _confirmedCallback(std_::move(confirmedCallback))
+, _confirmedCallback(std::move(confirmedCallback))
-, _cancelledCallback(std_::move(cancelledCallback)) {
+, _cancelledCallback(std::move(cancelledCallback)) {
 	init(text);
 }
 
@@ -76,8 +76,8 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
 , _cancelText(cancelText)
 , _confirmStyle(st::defaultBoxButton)
 , _text(st::boxWidth - st::boxPadding.left() - st::boxButtonPadding.right())
-, _confirmedCallback(std_::move(confirmedCallback))
+, _confirmedCallback(std::move(confirmedCallback))
-, _cancelledCallback(std_::move(cancelledCallback)) {
+, _cancelledCallback(std::move(cancelledCallback)) {
 	init(text);
 }
 
@@ -86,8 +86,8 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
 , _cancelText(cancelText)
 , _confirmStyle(st::defaultBoxButton)
 , _text(st::boxWidth - st::boxPadding.left() - st::boxButtonPadding.right())
-, _confirmedCallback(std_::move(confirmedCallback))
+, _confirmedCallback(std::move(confirmedCallback))
-, _cancelledCallback(std_::move(cancelledCallback)) {
+, _cancelledCallback(std::move(cancelledCallback)) {
 	init(text);
 }
 
@@ -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_copy<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_copy<void()> &&closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, doneText, std::move(closedCallback)) {
 }
 
 MaxInviteBox::MaxInviteBox(QWidget*, const QString &link)

Telegram/SourceFiles/boxes/confirmphonebox.cpp

@@ -106,7 +106,7 @@ void ConfirmPhoneBox::setCallStatus(const CallStatus &status) {
 
 void ConfirmPhoneBox::launch() {
 	if (!CurrentConfirmPhoneBox) return;
-	Ui::show(std_::move(CurrentConfirmPhoneBox));
+	Ui::show(std::move(CurrentConfirmPhoneBox));
 }
 
 void ConfirmPhoneBox::prepare() {

Telegram/SourceFiles/boxes/contactsbox.cpp

@@ -293,7 +293,7 @@ object_ptr<Ui::WidgetSlideWrap<Ui::MultiSelect>> ContactsBox::createMultiSelect(
 	auto entity = object_ptr<Ui::MultiSelect>(this, st::contactsMultiSelect, lang(lng_participant_filter));
 	auto margins = style::margins(0, 0, 0, 0);
 	auto callback = [this] { updateScrollSkips(); };
-	return object_ptr<Ui::WidgetSlideWrap<Ui::MultiSelect>>(this, std_::move(entity), margins, std_::move(callback));
+	return object_ptr<Ui::WidgetSlideWrap<Ui::MultiSelect>>(this, std::move(entity), margins, std::move(callback));
 }
 
 int ContactsBox::getTopScrollSkip() const {
@@ -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)
-: checkbox(std_::make_unique<Ui::RoundImageCheckbox>(st::contactsPhotoCheckbox, updateCallback, PaintUserpicCallback(peer))) {
+: checkbox(std::make_unique<Ui::RoundImageCheckbox>(st::contactsPhotoCheckbox, updateCallback, PaintUserpicCallback(peer))) {
 }
 
 ContactsBox::Inner::ContactData::~ContactData() = default;
@@ -568,7 +568,7 @@ ContactsBox::Inner::Inner(QWidget *parent, ChatData *chat, MembersFilter members
 , _aboutWidth(st::boxWideWidth - st::contactsPadding.left() - st::contactsPadding.right())
 , _aboutAllAdmins(st::defaultTextStyle, lang(lng_chat_about_all_admins), _defaultOptions, _aboutWidth)
 , _aboutAdmins(st::defaultTextStyle, lang(lng_chat_about_admins), _defaultOptions, _aboutWidth)
-, _customList((membersFilter == MembersFilter::Recent) ? std_::unique_ptr<Dialogs::IndexedList>() : std_::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Add))
+, _customList((membersFilter == MembersFilter::Recent) ? std::unique_ptr<Dialogs::IndexedList>() : std::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Add))
 , _contacts((membersFilter == MembersFilter::Recent) ? App::main()->contactsList() : _customList.get())
 , _addContactLnk(this, lang(lng_add_contact_button)) {
 	initList();
@@ -596,7 +596,7 @@ ContactsBox::Inner::Inner(QWidget *parent, UserData *bot) : TWidget(parent)
 , _rowHeight(st::contactsPadding.top() + st::contactsPhotoSize + st::contactsPadding.bottom())
 , _bot(bot)
 , _allAdmins(this, lang(lng_chat_all_members_admins), false, st::defaultBoxCheckbox)
-, _customList(std_::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Add))
+, _customList(std::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Add))
 , _contacts(_customList.get())
 , _addContactLnk(this, lang(lng_add_contact_button)) {
 	if (sharingBotGame()) {
@@ -1297,7 +1297,7 @@ void ContactsBox::Inner::addRipple(PeerData *peer, ContactData *data) {
 	auto rowTop = getSelectedRowTop();
 	if (!data->ripple) {
 		auto mask = Ui::RippleAnimation::rectMask(QSize(width(), _rowHeight));
-		data->ripple = std_::make_unique<Ui::RippleAnimation>(st::contactsRipple, std_::move(mask), [this, data] {
+		data->ripple = std::make_unique<Ui::RippleAnimation>(st::contactsRipple, std::move(mask), [this, data] {
 			updateRowWithTop(data->rippleRowTop);
 		});
 	}
@@ -1471,7 +1471,7 @@ void ContactsBox::Inner::peerUnselected(PeerData *peer) {
 }
 
 void ContactsBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback) {
-	_peerSelectedChangedCallback = std_::move(callback);
+	_peerSelectedChangedCallback = std::move(callback);
 }
 
 void ContactsBox::Inner::changePeerCheckState(ContactData *data, PeerData *peer, bool checked, ChangeStateWay useCallback) {

Telegram/SourceFiles/boxes/contactsbox.h

@@ -165,7 +165,7 @@ public:
 	QVector<MTPInputUser> selectedInputs();
 	bool allAdmins() const;
 	void setAllAdminsChangedCallback(base::lambda<void()> &&allAdminsChangedCallback) {
-		_allAdminsChangedCallback = std_::move(allAdminsChangedCallback);
+		_allAdminsChangedCallback = std::move(allAdminsChangedCallback);
 	}
 
 	void chooseParticipant();
@@ -221,8 +221,8 @@ private:
 		ContactData(PeerData *peer, const base::lambda_copy<void()> &updateCallback);
 		~ContactData();
 
-		std_::unique_ptr<Ui::RoundImageCheckbox> checkbox;
+		std::unique_ptr<Ui::RoundImageCheckbox> checkbox;
-		std_::unique_ptr<Ui::RippleAnimation> ripple;
+		std::unique_ptr<Ui::RippleAnimation> ripple;
 		int rippleRowTop = 0;
 		Text name;
 		QString statusText;
@@ -297,7 +297,7 @@ private:
 
 	int32 _time;
 
-	std_::unique_ptr<Dialogs::IndexedList> _customList;
+	std::unique_ptr<Dialogs::IndexedList> _customList;
 	Dialogs::IndexedList *_contacts = nullptr;
 	Dialogs::Row *_selected = nullptr;
 	Dialogs::Row *_pressed = nullptr;

Telegram/SourceFiles/boxes/editcolorbox.cpp

@@ -359,9 +359,9 @@ void EditColorBox::Slider::generatePixmap() {
 			++ints;
 		}
 		if (!isHorizontal()) {
-			image = std_::move(image).transformed(QTransform(0, -1, 1, 0, 0, 0));
+			image = std::move(image).transformed(QTransform(0, -1, 1, 0, 0, 0));
 		}
-		_pixmap = App::pixmapFromImageInPlace(std_::move(image));
+		_pixmap = App::pixmapFromImageInPlace(std::move(image));
 	} else {
 		auto color = anim::shifted(QColor(255, 255, 255, 255));
 		auto transparent = anim::shifted(QColor(255, 255, 255, 0));
@@ -377,9 +377,9 @@ void EditColorBox::Slider::generatePixmap() {
 			ints += intsPerLineAdded;
 		}
 		if (!isHorizontal()) {
-			image = std_::move(image).transformed(QTransform(0, -1, 1, 0, 0, 0));
+			image = std::move(image).transformed(QTransform(0, -1, 1, 0, 0, 0));
 		}
-		_mask = std_::move(image);
+		_mask = std::move(image);
 		updatePixmapFromMask();
 	}
 }

Telegram/SourceFiles/boxes/editcolorbox.h

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

Telegram/SourceFiles/boxes/members_box.cpp

@@ -109,9 +109,9 @@ void MembersBox::onAdd() {
 	}
 	auto box = Box<ContactsBox>(_inner->channel(), _inner->filter(), _inner->already());
 	if (_inner->filter() == MembersFilter::Recent) {
-		Ui::show(std_::move(box));
+		Ui::show(std::move(box));
 	} else {
-		_addBox = Ui::show(std_::move(box), KeepOtherLayers);
+		_addBox = Ui::show(std::move(box), KeepOtherLayers);
 		if (_addBox) {
 			connect(_addBox, SIGNAL(adminAdded()), this, SLOT(onAdminAdded()));
 		}
@@ -240,7 +240,7 @@ void MembersBox::Inner::addRipple(MemberData *data) {
 	auto rowTop = getSelectedRowTop();
 	if (!data->ripple) {
 		auto mask = Ui::RippleAnimation::rectMask(QSize(width(), _rowHeight));
-		data->ripple = std_::make_unique<Ui::RippleAnimation>(st::contactsRipple, std_::move(mask), [this, data] {
+		data->ripple = std::make_unique<Ui::RippleAnimation>(st::contactsRipple, std::move(mask), [this, data] {
 			updateRowWithTop(data->rippleRowTop);
 		});
 	}

Telegram/SourceFiles/boxes/members_box.h

@@ -129,7 +129,7 @@ private:
 		MemberData();
 		~MemberData();
 
-		std_::unique_ptr<Ui::RippleAnimation> ripple;
+		std::unique_ptr<Ui::RippleAnimation> ripple;
 		int rippleRowTop = 0;
 		Text name;
 		QString online;

Telegram/SourceFiles/boxes/notifications_box.cpp

@@ -250,7 +250,7 @@ void NotificationsBox::prepareNotificationSampleSmall() {
 		auto closeLeft = width - 2 * padding;
 		p.fillRect(rtlrect(closeLeft, padding, padding, padding, width), st::notificationSampleCloseFg);
 	}
-	_notificationSampleSmall = App::pixmapFromImageInPlace(std_::move(sampleImage));
+	_notificationSampleSmall = App::pixmapFromImageInPlace(std::move(sampleImage));
 	_notificationSampleSmall.setDevicePixelRatio(cRetinaFactor());
 }
 
@@ -294,7 +294,7 @@ void NotificationsBox::prepareNotificationSampleLarge() {
 		st::notifyClose.icon.paint(p, w - st::notifyClosePos.x() - st::notifyClose.width + st::notifyClose.iconPosition.x(), st::notifyClosePos.y() + st::notifyClose.iconPosition.y(), w);
 	}
 
-	_notificationSampleLarge = App::pixmapFromImageInPlace(std_::move(sampleImage));
+	_notificationSampleLarge = App::pixmapFromImageInPlace(std::move(sampleImage));
 }
 
 void NotificationsBox::removeSample(SampleWidget *widget) {
@@ -366,7 +366,7 @@ void NotificationsBox::setOverCorner(Notify::ScreenCorner corner) {
 		auto sampleLeft = (isLeft == rtl()) ? (r.x() + r.width() - st::notifyWidth - st::notifyDeltaX) : (r.x() + st::notifyDeltaX);
 		auto sampleTop = isTop ? (r.y() + st::notifyDeltaY) : (r.y() + r.height() - st::notifyDeltaY - st::notifyMinHeight);
 		for (int i = samplesLeave; i != samplesNeeded; ++i) {
-			auto widget = std_::make_unique<SampleWidget>(this, _notificationSampleLarge);
+			auto widget = std::make_unique<SampleWidget>(this, _notificationSampleLarge);
 			widget->move(sampleLeft, sampleTop + (isTop ? 1 : -1) * i * (st::notifyMinHeight + st::notifyDeltaY));
 			widget->showFast();
 			samples.push_back(widget.release());

Telegram/SourceFiles/boxes/notifications_box.h

@@ -63,7 +63,7 @@ private:
 	QPixmap _notificationSampleSmall;
 	QPixmap _notificationSampleLarge;
 	ScreenCorner _chosenCorner;
-	std_::vector_of_moveable<Animation> _sampleOpacities;
+	std::vector<Animation> _sampleOpacities;
 
 	bool _isOverCorner = false;
 	ScreenCorner _overCorner = ScreenCorner::TopLeft;

Telegram/SourceFiles/boxes/send_files_box.cpp

@@ -93,9 +93,9 @@ SendFilesBox::SendFilesBox(QWidget*, const QString &filepath, QImage image, Comp
 			}
 			_previewLeft = (st::boxWideWidth - _previewWidth) / 2;
 
-			image = std_::move(image).scaled(_previewWidth * cIntRetinaFactor(), _previewHeight * cIntRetinaFactor(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+			image = std::move(image).scaled(_previewWidth * cIntRetinaFactor(), _previewHeight * cIntRetinaFactor(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
-			image = Images::prepareOpaque(std_::move(image));
+			image = Images::prepareOpaque(std::move(image));
-			_preview = App::pixmapFromImageInPlace(std_::move(image));
+			_preview = App::pixmapFromImageInPlace(std::move(image));
 			_preview.setDevicePixelRatio(cRetinaFactor());
 		}
 	}

Telegram/SourceFiles/boxes/send_files_box.h

@@ -38,10 +38,10 @@ public:
 	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) {
-		_confirmedCallback = std_::move(callback);
+		_confirmedCallback = std::move(callback);
 	}
 	void setCancelledCallback(base::lambda<void()> &&callback) {
-		_cancelledCallback = std_::move(callback);
+		_cancelledCallback = std::move(callback);
 	}
 
 	void closeHook() override;

Telegram/SourceFiles/boxes/sharebox.cpp

@@ -41,9 +41,9 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include "boxes/contactsbox.h"
 
 ShareBox::ShareBox(QWidget*, CopyCallback &&copyCallback, SubmitCallback &&submitCallback, FilterCallback &&filterCallback)
-: _copyCallback(std_::move(copyCallback))
+: _copyCallback(std::move(copyCallback))
-, _submitCallback(std_::move(submitCallback))
+, _submitCallback(std::move(submitCallback))
-, _filterCallback(std_::move(filterCallback))
+, _filterCallback(std::move(filterCallback))
 , _select(this, st::contactsMultiSelect, lang(lng_participant_filter))
 , _searchTimer(this) {
 }
@@ -54,7 +54,7 @@ void ShareBox::prepare() {
 
 	setTitle(lang(lng_share_title));
 
-	_inner = setInnerWidget(object_ptr<Inner>(this, std_::move(_filterCallback)), getTopScrollSkip());
+	_inner = setInnerWidget(object_ptr<Inner>(this, std::move(_filterCallback)), getTopScrollSkip());
 	connect(_inner, SIGNAL(mustScrollTo(int,int)), this, SLOT(onMustScrollTo(int,int)));
 
 	createButtons();
@@ -272,8 +272,8 @@ void ShareBox::scrollAnimationCallback() {
 }
 
 ShareBox::Inner::Inner(QWidget *parent, ShareBox::FilterCallback &&filterCallback) : TWidget(parent)
-, _filterCallback(std_::move(filterCallback))
+, _filterCallback(std::move(filterCallback))
-, _chatsIndexed(std_::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Add)) {
+, _chatsIndexed(std::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Add)) {
 	_rowsTop = st::shareRowsTop;
 	_rowHeight = st::shareRowHeight;
 	setAttribute(Qt::WA_OpaquePaintEvent);
@@ -649,7 +649,7 @@ void ShareBox::Inner::peerUnselected(PeerData *peer) {
 }
 
 void ShareBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback) {
-	_peerSelectedChangedCallback = std_::move(callback);
+	_peerSelectedChangedCallback = std::move(callback);
 }
 
 void ShareBox::Inner::changePeerCheckState(Chat *chat, bool checked, ChangeStateWay useCallback) {
@@ -903,7 +903,7 @@ void shareGameScoreFromItem(HistoryItem *item) {
 					MTPVector<MTPlong> random = MTP_vector<MTPlong>(1, rand_value<MTPlong>());
 					auto request = MTPmessages_ForwardMessages(MTP_flags(sendFlags), item->history()->peer->input, msgIds, random, peer->input);
 					auto callback = doneCallback;
-					auto requestId = MTP::send(request, rpcDone(std_::move(callback)));
+					auto requestId = MTP::send(request, rpcDone(std::move(callback)));
 					data->requests.insert(requestId);
 				}
 			}
@@ -918,7 +918,7 @@ void shareGameScoreFromItem(HistoryItem *item) {
 		}
 		return false;
 	};
-	Ui::show(Box<ShareBox>(std_::move(copyCallback), std_::move(submitCallback), std_::move(filterCallback)));
+	Ui::show(Box<ShareBox>(std::move(copyCallback), std::move(submitCallback), std::move(filterCallback)));
 }
 
 } // namespace

Telegram/SourceFiles/boxes/sharebox.h

@@ -22,7 +22,6 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 
 #include "boxes/abstractbox.h"
 #include "core/observer.h"
-#include "core/vector_of_moveable.h"
 #include "ui/effects/round_checkbox.h"
 
 namespace Dialogs {
@@ -194,7 +193,7 @@ private:
 	int _upon = -1;
 
 	ShareBox::FilterCallback _filterCallback;
-	std_::unique_ptr<Dialogs::IndexedList> _chatsIndexed;
+	std::unique_ptr<Dialogs::IndexedList> _chatsIndexed;
 	QString _filter;
 	using FilteredDialogs = QVector<Dialogs::Row*>;
 	FilteredDialogs _filtered;

Telegram/SourceFiles/boxes/stickers_box.cpp

@@ -118,16 +118,16 @@ void StickersBox::CounterWidget::updateCounter() {
 template <typename ...Args>
 StickersBox::Tab::Tab(int index, Args&&... args)
 : _index(index)
-, _widget(std_::forward<Args>(args)...)
+, _widget(std::forward<Args>(args)...)
 , _weak(_widget) {
 }
 
 object_ptr<StickersBox::Inner> StickersBox::Tab::takeWidget() {
-	return std_::move(_widget);
+	return std::move(_widget);
 }
 
 void StickersBox::Tab::returnWidget(object_ptr<Inner> widget) {
-	_widget = std_::move(widget);
+	_widget = std::move(widget);
 	t_assert(_widget == _weak);
 }
 
@@ -398,7 +398,7 @@ void StickersBox::switchTab() {
 		auto widget = takeInnerWidget<Inner>();
 		widget->setParent(this);
 		widget->hide();
-		_tab->returnWidget(std_::move(widget));
+		_tab->returnWidget(std::move(widget));
 		_tab = newTab;
 		_section = newSection;
 		setInnerWidget(_tab->takeWidget(), getTopSkip());
@@ -410,8 +410,8 @@ void StickersBox::switchTab() {
 		auto nowCache = grabContentCache();
 		auto nowIndex = _tab->index();
 
-		_slideAnimation = std_::make_unique<Ui::SlideAnimation>();
+		_slideAnimation = std::make_unique<Ui::SlideAnimation>();
-		_slideAnimation->setSnapshots(std_::move(wasCache), std_::move(nowCache));
+		_slideAnimation->setSnapshots(std::move(wasCache), std::move(nowCache));
 		auto slideLeft = wasIndex > nowIndex;
 		_slideAnimation->start(slideLeft, [this] { update(); }, st::slideDuration);
 		setInnerVisible(false);
@@ -425,7 +425,7 @@ QPixmap StickersBox::grabContentCache() {
 	_tabs->hide();
 	auto result = grabInnerCache();
 	_tabs->show();
-	return std_::move(result);
+	return std::move(result);
 }
 
 void StickersBox::installSet(uint64 setId) {
@@ -796,16 +796,16 @@ void StickersBox::Inner::setActionDown(int newActionDown) {
 				if (set->removed) {
 					auto rippleSize = QSize(_undoWidth - st::stickersUndoRemove.width, st::stickersUndoRemove.height);
 					auto rippleMask = Ui::RippleAnimation::roundRectMask(rippleSize, st::buttonRadius);
-					ensureRipple(st::stickersUndoRemove.ripple, std_::move(rippleMask), removeButton);
+					ensureRipple(st::stickersUndoRemove.ripple, std::move(rippleMask), removeButton);
 				} else {
 					auto rippleSize = st::stickersRemove.rippleAreaSize;
 					auto rippleMask = Ui::RippleAnimation::ellipseMask(QSize(rippleSize, rippleSize));
-					ensureRipple(st::stickersRemove.ripple, std_::move(rippleMask), removeButton);
+					ensureRipple(st::stickersRemove.ripple, std::move(rippleMask), removeButton);
 				}
 			} else if (!set->installed || set->archived || set->removed) {
 				auto rippleSize = QSize(_addWidth - st::stickersTrendingAdd.width, st::stickersTrendingAdd.height);
 				auto rippleMask = Ui::RippleAnimation::roundRectMask(rippleSize, st::buttonRadius);
-				ensureRipple(st::stickersTrendingAdd.ripple, std_::move(rippleMask), removeButton);
+				ensureRipple(st::stickersTrendingAdd.ripple, std::move(rippleMask), removeButton);
 			}
 		}
 		if (set->ripple) {
@@ -816,7 +816,7 @@ void StickersBox::Inner::setActionDown(int newActionDown) {
 }
 
 void StickersBox::Inner::ensureRipple(const style::RippleAnimation &st, QImage mask, bool removeButton) {
-	_rows[_actionDown]->ripple = MakeShared<Ui::RippleAnimation>(st, std_::move(mask), [this, index = _actionDown, removeButton] {
+	_rows[_actionDown]->ripple = MakeShared<Ui::RippleAnimation>(st, std::move(mask), [this, index = _actionDown, removeButton] {
 		update(myrtlrect(relativeButtonRect(removeButton).translated(0, _itemsTop + index * _rowHeight)));
 	});
 }

Telegram/SourceFiles/boxes/stickers_box.h

@@ -123,7 +123,7 @@ private:
 	Tab _archived;
 	Tab *_tab = nullptr;
 
-	std_::unique_ptr<Ui::SlideAnimation> _slideAnimation;
+	std::unique_ptr<Ui::SlideAnimation> _slideAnimation;
 	object_ptr<BoxLayerTitleShadow> _titleShadow = { nullptr };
 
 	int _aboutWidth = 0;
@@ -164,10 +164,10 @@ public:
 	void setRemovedSets(const Stickers::Order &removed);
 
 	void setInstallSetCallback(base::lambda<void(uint64 setId)> &&callback) {
-		_installSetCallback = std_::move(callback);
+		_installSetCallback = std::move(callback);
 	}
 	void setLoadMoreCallback(base::lambda<void()> &&callback) {
-		_loadMoreCallback = std_::move(callback);
+		_loadMoreCallback = std::move(callback);
 	}
 
 	void setVisibleTopBottom(int visibleTop, int visibleBottom) override;

Telegram/SourceFiles/boxes/stickersetbox.h

@@ -21,7 +21,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #pragma once
 
 #include "boxes/abstractbox.h"
-#include "core/vector_of_moveable.h"
+#include <vector>
 
 class ConfirmBox;
 
@@ -111,7 +111,7 @@ private:
 		return (_setFlags & MTPDstickerSet::Flag::f_masks);
 	}
 
-	std_::vector_of_moveable<Animation> _packOvers;
+	std::vector<Animation> _packOvers;
 	StickerPack _pack;
 	StickersByEmojiMap _emoji;
 	bool _loaded = false;

Telegram/SourceFiles/core/basic_types.h

@@ -22,12 +22,10 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 
 #include <string>
 #include <exception>
+#include <memory>
 #include <ctime>
 
-#include <QtCore/QReadWriteLock>
-
 #include "core/build_config.h"
-#include "core/stl_subset.h"
 #include "core/ordered_set.h"
 
 //using uchar = unsigned char; // Qt has uchar

Telegram/SourceFiles/core/click_handler.h

@@ -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) {

Telegram/SourceFiles/core/lambda.h

@@ -20,7 +20,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 */
 #pragma once
 
-#include "core/stl_subset.h"
+#include <memory>
 
 namespace base {
 namespace internal {
@@ -57,7 +57,7 @@ namespace internal {
 		using alignment = uint64;
 
 		template <typename Lambda>
-		using IsLarge = std_::integral_constant<bool, !(sizeof(std_::decay_simple_t<Lambda>) <= kStorageSize)>;
+		using IsLarge = std::integral_constant<bool, !(sizeof(std::decay_t<Lambda>) <= kStorageSize)>;
 
 	protected:
 		static void bad_construct_copy(void *lambda, const void *source) {
@@ -95,20 +95,20 @@ namespace internal {
 	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...> {
+	struct lambda_wrap_helper_move_impl<Lambda, std::true_type, Return, Args...> : public lambda_wrap_helper_base<Return, Args...> {
-		using JustLambda = std_::decay_simple_t<Lambda>;
+		using JustLambda = std::decay_t<Lambda>;
-		using LambdaPtr = std_::unique_ptr<JustLambda>;
+		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));
+			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)));
+			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)...);
+			return (**static_cast<const LambdaPtr*>(lambda))(std::forward<Args>(args)...);
 		}
 		static void destruct_method(const void *lambda) {
 			static_cast<const LambdaPtr*>(lambda)->~LambdaPtr();
@@ -133,8 +133,8 @@ namespace internal {
 	};
 
 	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...> {
+	struct lambda_wrap_helper_move_impl<Lambda, std::false_type, Return, Args...> : public lambda_wrap_helper_base<Return, Args...> {
-		using JustLambda = std_::decay_simple_t<Lambda>;
+		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);
@@ -143,13 +143,13 @@ namespace internal {
 		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);
+			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)...);
+			return (*static_cast<const JustLambda*>(lambda))(std::forward<Args>(args)...);
 		}
 		static void destruct_method(const void *lambda) {
 			static_cast<const JustLambda*>(lambda)->~JustLambda();
@@ -186,17 +186,17 @@ namespace internal {
 	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...> {
+	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_simple_t<Lambda>;
+		using JustLambda = std::decay_t<Lambda>;
-		using LambdaPtr = std_::unique_ptr<JustLambda>;
+		using LambdaPtr = std::unique_ptr<JustLambda>;
-		using Parent = lambda_wrap_helper_move_impl<Lambda, std_::true_type, Return, Args...>;
+		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()));
+			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)));
+			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) {
 		}
@@ -204,9 +204,9 @@ namespace internal {
 	};
 
 	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...> {
+	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_simple_t<Lambda>;
+		using JustLambda = std::decay_t<Lambda>;
-		using Parent = lambda_wrap_helper_move_impl<Lambda, std_::false_type, Return, Args...>;
+		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));
@@ -214,7 +214,7 @@ namespace internal {
 		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);
+			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));
@@ -245,13 +245,13 @@ class lambda<Return(Args...)> {
 	using EmptyHelper = internal::lambda_wrap_empty<Return, Args...>;
 
 	template <typename Lambda>
-	using IsUnique = std_::is_same<lambda, std_::decay_simple_t<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_simple_t<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>;
+	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>;
+	using IsRvalue = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>;
 
 public:
 	using return_type = Return;
@@ -266,7 +266,7 @@ public:
 		helper_->construct_move_other(storage_, other.storage_);
 	}
 	lambda &operator=(lambda &&other) {
-		auto temp = std_::move(other);
+		auto temp = std::move(other);
 		helper_->destruct(storage_);
 		helper_ = temp.helper_;
 		helper_->construct_move_other(storage_, temp.storage_);
@@ -274,7 +274,7 @@ public:
 	}
 
 	void swap(lambda &other) {
-		if (this != &other) std_::swap_moveable(*this, other);
+		if (this != &other) std::swap(*this, other);
 	}
 
 	template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
@@ -284,7 +284,7 @@ public:
 
 	template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
 	lambda &operator=(Lambda &&other) {
-		auto temp = std_::move(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);
@@ -292,7 +292,7 @@ public:
 	}
 
 	inline Return operator()(Args... args) const {
-		return helper_->call(storage_, std_::forward<Args>(args)...);
+		return helper_->call(storage_, std::forward<Args>(args)...);
 	}
 
 	explicit operator bool() const {
@@ -322,11 +322,11 @@ class lambda_copy<Return(Args...)> : public lambda<Return(Args...)> {
 	using Parent = lambda<Return(Args...)>;
 
 	template <typename Lambda>
-	using IsOther = std_::enable_if_t<!std_::is_same<lambda_copy, std_::decay_simple_t<Lambda>>::value>;
+	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>;
+	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>;
+	using IsNotRvalue = std::enable_if_t<!std::is_rvalue_reference<Lambda&&>::value>;
 
 public:
 	lambda_copy() = default;
@@ -344,7 +344,7 @@ public:
 	lambda_copy &operator=(lambda_copy &&other) = default;
 
 	void swap(lambda_copy &other) {
-		if (this != &other) std_::swap_moveable(*this, other);
+		if (this != &other) std::swap(*this, other);
 	}
 
 	lambda_copy clone() const {
@@ -372,7 +372,7 @@ public:
 
 	template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
 	lambda_copy &operator=(Lambda &&other) {
-		auto temp = std_::move(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);
@@ -423,7 +423,7 @@ 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 lambda_guard_data(PointersAndLambda&&... qobjectsAndLambda) : _lambda(init(_pointers, std::forward<PointersAndLambda>(qobjectsAndLambda)...)) {
 	}
 
 	inline lambda_guard_data(const lambda_guard_data &other) : _lambda(other._lambda) {
@@ -439,17 +439,17 @@ public:
 				return return_type();
 			}
 		}
-		return _lambda(std_::forward<Args>(args)...);
+		return _lambda(std::forward<Args>(args)...);
 	}
 
 private:
 	template <typename ...PointersAndLambda>
 	Lambda init(QPointer<QObject> *pointers, QObject *qobject, PointersAndLambda&&... qobjectsAndLambda) {
 		*pointers = qobject;
-		return init(++pointers, std_::forward<PointersAndLambda>(qobjectsAndLambda)...);
+		return init(++pointers, std::forward<PointersAndLambda>(qobjectsAndLambda)...);
 	}
 	Lambda init(QPointer<QObject> *pointers, Lambda &&lambda) {
-		return std_::move(lambda);
+		return std::move(lambda);
 	}
 
 	QPointer<QObject> _pointers[N];
@@ -463,29 +463,29 @@ 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 lambda_guard(PointersAndLambda&&... qobjectsAndLambda) : _data(std::make_unique<lambda_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 lambda_guard(const lambda_guard &&other) : _data(std::move(other._data)) {
 	}
 
-	inline lambda_guard(lambda_guard &&other) : _data(std_::move(other._data)) {
+	inline lambda_guard(lambda_guard &&other) : _data(std::move(other._data)) {
 	}
 
 	inline lambda_guard &operator=(const lambda_guard &&other) {
-		_data = std_::move(other._data);
+		_data = std::move(other._data);
 		return *this;
 	}
 
 	inline lambda_guard &operator=(lambda_guard &&other) {
-		_data = std_::move(other._data);
+		_data = std::move(other._data);
 		return *this;
 	}
 
 	template <typename ...Args>
 	inline return_type operator()(Args&&... args) const {
-		return (*_data)(std_::forward<Args>(args)...);
+		return (*_data)(std::forward<Args>(args)...);
 	}
 
 	bool isNull() const {
@@ -497,10 +497,10 @@ public:
 	}
 
 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))) {
+	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<lambda_guard_data<N, Lambda>> _data;
 
 };
 
@@ -536,7 +536,7 @@ struct lambda_type_helper<lambda_guard<N, Lambda>> {
 template <typename ...PointersAndLambda>
 inline internal::lambda_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 internal::lambda_guard_t<PointersAndLambda...>(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
 }
 
 // Pass lambda instead of a Qt void() slot.
@@ -545,7 +545,7 @@ 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<void()> &&lambda) : QObject(parent), _lambda(std::move(lambda)) {
 	}
 
 public slots:
@@ -559,14 +559,14 @@ private:
 };
 
 inline lambda_slot_wrap *lambda_slot(QObject *parent, lambda<void()> &&lambda) {
-	return new lambda_slot_wrap(parent, std_::move(lambda));
+	return new lambda_slot_wrap(parent, std::move(lambda));
 }
 
 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<void()> &&lambda) : QObject(parent), _lambda(std::move(lambda)) {
 	}
 
 public slots :
@@ -581,7 +581,7 @@ private:
 };
 
 inline lambda_slot_once_wrap *lambda_slot_once(QObject *parent, lambda<void()> &&lambda) {
-	return new lambda_slot_once_wrap(parent, std_::move(lambda));
+	return new lambda_slot_once_wrap(parent, std::move(lambda));
 }
 
 } // namespace base

Telegram/SourceFiles/core/observer.h

@@ -20,7 +20,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 */
 #pragma once
 
-#include "core/vector_of_moveable.h"
+#include <vector>
 #include "core/type_traits.h"
 
 namespace base {
@@ -117,7 +117,7 @@ public:
 		if (!_data) {
 			_data = MakeShared<ObservableData<EventType, Handler>>(this);
 		}
-		return _data->append(std_::move(handler));
+		return _data->append(std::move(handler));
 	}
 
 private:
@@ -133,7 +133,7 @@ class BaseObservable<EventType, Handler, true> : public internal::CommonObservab
 public:
 	void notify(EventType event, bool sync = false) {
 		if (this->_data) {
-			this->_data->notify(std_::move(event), sync);
+			this->_data->notify(std::move(event), sync);
 		}
 	}
 
@@ -144,7 +144,7 @@ class BaseObservable<EventType, Handler, false> : public internal::CommonObserva
 public:
 	void notify(EventType &&event, bool sync = false) {
 		if (this->_data) {
-			this->_data->notify(std_::move(event), sync);
+			this->_data->notify(std::move(event), sync);
 		}
 	}
 	void notify(const EventType &event, bool sync = false) {
@@ -166,7 +166,7 @@ public:
 	}
 
 	Subscription append(Handler &&handler) {
-		auto node = new Node(_observable->_data, std_::move(handler));
+		auto node = new Node(_observable->_data, std::move(handler));
 		if (_begin) {
 			_end->next = node;
 			node->prev = _end;
@@ -183,7 +183,7 @@ public:
 
 private:
 	struct Node : public Subscription::Node {
-		Node(const QSharedPointer<BaseObservableData> &observer, Handler &&handler) : Subscription::Node(observer), handler(std_::move(handler)) {
+		Node(const QSharedPointer<BaseObservableData> &observer, Handler &&handler) : Subscription::Node(observer), handler(std::move(handler)) {
 		}
 		Handler handler;
 	};
@@ -253,7 +253,7 @@ public:
 			sync = false;
 		}
 		if (sync) {
-			_events.push_back(std_::move(event));
+			_events.push_back(std::move(event));
 			callHandlers();
 		} else {
 			if (!this->_callHandlers) {
@@ -264,7 +264,7 @@ public:
 			if (_events.empty()) {
 				RegisterPendingObservable(&this->_callHandlers);
 			}
-			_events.push_back(std_::move(event));
+			_events.push_back(std::move(event));
 		}
 	}
 
@@ -285,7 +285,7 @@ private:
 		UnregisterActiveObservable(&this->_callHandlers);
 	}
 
-	std_::vector_of_moveable<EventType> _events;
+	std::vector<EventType> _events;
 	bool _handling = false;
 
 };
@@ -404,23 +404,23 @@ class Subscriber {
 protected:
 	template <typename EventType, typename Handler, typename Lambda>
 	int subscribe(base::Observable<EventType, Handler> &observable, Lambda &&handler) {
-		_subscriptions.push_back(observable.add_subscription(std_::forward<Lambda>(handler)));
+		_subscriptions.push_back(observable.add_subscription(std::forward<Lambda>(handler)));
 		return _subscriptions.size();
 	}
 
 	template <typename EventType, typename Handler, typename Lambda>
 	int subscribe(base::Observable<EventType, Handler> *observable, Lambda &&handler) {
-		return subscribe(*observable, std_::forward<Lambda>(handler));
+		return subscribe(*observable, std::forward<Lambda>(handler));
 	}
 
 	template <typename Type, typename Lambda>
 	int subscribe(base::Variable<Type> &variable, Lambda &&handler) {
-		return subscribe(variable.observable(), std_::forward<Lambda>(handler));
+		return subscribe(variable.observable(), std::forward<Lambda>(handler));
 	}
 
 	template <typename Type, typename Lambda>
 	int subscribe(base::Variable<Type> *variable, Lambda &&handler) {
-		return subscribe(variable->observable(), std_::forward<Lambda>(handler));
+		return subscribe(variable->observable(), std::forward<Lambda>(handler));
 	}
 
 	void unsubscribe(int index) {
@@ -442,7 +442,7 @@ protected:
 	}
 
 private:
-	std_::vector_of_moveable<base::Subscription> _subscriptions;
+	std::vector<base::Subscription> _subscriptions;
 
 };
 

Telegram/SourceFiles/core/qthelp_regex.h

@@ -24,16 +24,16 @@ namespace qthelp {
 
 class RegularExpressionMatch {
 public:
-	RegularExpressionMatch(QRegularExpressionMatch &&match) : data_(std_::move(match)) {
+	RegularExpressionMatch(QRegularExpressionMatch &&match) : data_(std::move(match)) {
 	}
-	RegularExpressionMatch(RegularExpressionMatch &&other) : data_(std_::move(other.data_)) {
+	RegularExpressionMatch(RegularExpressionMatch &&other) : data_(std::move(other.data_)) {
 	}
 	RegularExpressionMatch &operator=(QRegularExpressionMatch &&match) {
-		data_ = std_::move(match);
+		data_ = std::move(match);
 		return *this;
 	}
 	RegularExpressionMatch &operator=(RegularExpressionMatch &&other) {
-		data_ = std_::move(other.data_);
+		data_ = std::move(other.data_);
 		return *this;
 	}
 	QRegularExpressionMatch *operator->() {

Telegram/SourceFiles/core/runtime_composer.h

@@ -97,7 +97,7 @@ protected:
 		((Type*)location)->~Type();
 	}
 	static void RuntimeComponentMove(void *location, void *waslocation) {
-		*(Type*)location = std_::move(*(Type*)waslocation);
+		*(Type*)location = std::move(*(Type*)waslocation);
 	}
 
 };
@@ -164,7 +164,7 @@ public:
 					try {
 						auto constructAt = _dataptrunsafe(offset);
 						auto space = RuntimeComponentWraps[i].Size;
-						auto alignedAt = std_::align(RuntimeComponentWraps[i].Align, space, constructAt, space);
+						auto alignedAt = std::align(RuntimeComponentWraps[i].Align, space, constructAt, space);
 						t_assert(alignedAt == constructAt);
 						RuntimeComponentWraps[i].Construct(constructAt, this);
 					} catch (...) {

Telegram/SourceFiles/core/single_timer.cpp

@@ -37,7 +37,7 @@ void SingleTimer::setTimeoutHandler(base::lambda<void()> &&handler) {
 	} else if (handler && !_handler) {
 		connect(this, SIGNAL(timeout()), this, SLOT(onTimeout()));
 	}
-	_handler = std_::move(handler);
+	_handler = std::move(handler);
 }
 
 void SingleTimer::adjust() {

Telegram/SourceFiles/core/stl_subset.h

@@ -1,297 +0,0 @@
-/*
-This file is part of Telegram Desktop,
-the official desktop version of Telegram messaging app, see https://telegram.org
-
-Telegram Desktop is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-It is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-In addition, as a special exception, the copyright holders give permission
-to link the code of portions of this program with the OpenSSL library.
-
-Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
-Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
-*/
-#pragma once
-
-#include <stdint.h>
-
-// we copy some parts of C++11/14/17 std:: library, because on OS X 10.6+
-// version we can use C++11/14/17, but we can not use its library :(
-namespace std_ {
-
-using nullptr_t = decltype(nullptr);
-
-template <typename T, T V>
-struct integral_constant {
-	static constexpr T value = V;
-
-	using value_type = T;
-	using type = integral_constant<T, V>;
-
-	constexpr operator value_type() const noexcept {
-		return (value);
-	}
-
-	constexpr value_type operator()() const noexcept {
-		return (value);
-	}
-};
-
-using true_type = integral_constant<bool, true>;
-using false_type = integral_constant<bool, false>;
-
-template <typename T>
-struct remove_reference {
-	using type = T;
-};
-template <typename T>
-struct remove_reference<T&> {
-	using type = T;
-};
-template <typename T>
-struct remove_reference<T&&> {
-	using type = T;
-};
-template <typename T>
-using remove_reference_t = typename remove_reference<T>::type;
-
-template <typename T>
-struct is_lvalue_reference : false_type {
-};
-template <typename T>
-struct is_lvalue_reference<T&> : true_type {
-};
-
-template <typename T>
-struct is_rvalue_reference : false_type {
-};
-template <typename T>
-struct is_rvalue_reference<T&&> : true_type {
-};
-
-template <typename T>
-inline constexpr T &&forward(typename remove_reference<T>::type &value) noexcept {
-	return static_cast<T&&>(value);
-}
-template <typename T>
-inline constexpr T &&forward(typename remove_reference<T>::type &&value) noexcept {
-	static_assert(!is_lvalue_reference<T>::value, "bad forward call");
-	return static_cast<T&&>(value);
-}
-
-template <typename T>
-inline constexpr typename remove_reference<T>::type &&move(T &&value) noexcept {
-	return static_cast<typename remove_reference<T>::type&&>(value);
-}
-
-template <typename T>
-void swap_moveable(T &a, T &b) {
-	T tmp = move(a);
-	a = move(b);
-	b = move(tmp);
-}
-
-template <typename T>
-struct remove_const {
-	using type = T;
-};
-
-template <typename T>
-struct remove_const<const T> {
-	using type = T;
-};
-
-template <typename T>
-struct remove_volatile {
-	using type = T;
-};
-
-template <typename T>
-struct remove_volatile<volatile T> {
-	using type = T;
-};
-
-template <typename T>
-using decay_simple_t = typename remove_const<typename remove_volatile<typename remove_reference<T>::type>::type>::type;
-
-template <typename T1, typename T2>
-struct is_same : false_type {
-};
-
-template <typename T>
-struct is_same<T, T> : true_type {
-};
-
-template <bool, typename T = void>
-struct enable_if {
-};
-
-template <typename T>
-struct enable_if<true, T> {
-	using type = T;
-};
-
-template <bool Test, typename T = void>
-using enable_if_t = typename enable_if<Test, T>::type;
-
-template <bool, typename First, typename Second>
-struct conditional {
-	using type = Second;
-};
-
-template <typename First, typename Second>
-struct conditional<true, First, Second> {
-	using type = First;
-};
-
-template <bool Test, typename First, typename Second>
-using conditional_t = typename conditional<Test, First, Second>::type;
-
-template <typename T>
-struct add_const {
-	using type = const T;
-};
-
-template <typename T>
-using add_const_t = typename add_const<T>::type;
-
-// This is not full unique_ptr, but at least with std interface.
-template <typename T>
-class unique_ptr {
-public:
-	constexpr unique_ptr() noexcept = default;
-	unique_ptr(const unique_ptr<T> &) = delete;
-	unique_ptr<T> &operator=(const unique_ptr<T> &) = delete;
-
-	constexpr unique_ptr(std_::nullptr_t) {
-	}
-	unique_ptr<T> &operator=(std_::nullptr_t) noexcept {
-		reset();
-		return (*this);
-	}
-
-	explicit unique_ptr(T *p) noexcept : _p(p) {
-	}
-
-	template <typename U>
-	unique_ptr(unique_ptr<U> &&other) noexcept : _p(other.release()) {
-	}
-	template <typename U>
-	unique_ptr<T> &operator=(unique_ptr<U> &&other) noexcept {
-		reset(other.release());
-		return (*this);
-	}
-	unique_ptr<T> &operator=(unique_ptr<T> &&other) noexcept {
-		if (this != &other) {
-			reset(other.release());
-		}
-		return (*this);
-	}
-
-	void swap(unique_ptr<T> &other) noexcept {
-		std::swap(_p, other._p);
-	}
-	~unique_ptr() noexcept {
-		if (_p) {
-			static_assert(sizeof(T) > 0, "can't delete an incomplete type");
-			delete _p;
-			_p = nullptr;
-		}
-	}
-
-	T &operator*() const {
-		return (*get());
-	}
-	T *operator->() const noexcept {
-		return get();
-	}
-	T *get() const noexcept {
-		return _p;
-	}
-	explicit operator bool() const noexcept {
-		return get() != nullptr;
-	}
-
-	T *release() noexcept {
-		auto old = _p;
-		_p = nullptr;
-		return old;
-	}
-
-	void reset(T *p = nullptr) noexcept {
-		auto old = _p;
-		_p = p;
-		if (old) {
-			static_assert(sizeof(T) > 0, "can't delete an incomplete type");
-			delete old;
-		}
-	}
-
-private:
-	T *_p = nullptr;
-
-};
-
-template <typename T, typename... Args>
-inline unique_ptr<T> make_unique(Args&&... args) {
-	return unique_ptr<T>(new T(forward<Args>(args)...));
-}
-
-template <typename T>
-inline bool operator==(const unique_ptr<T> &a, std_::nullptr_t) noexcept {
-	return !a;
-}
-template <typename T>
-inline bool operator==(std_::nullptr_t, const unique_ptr<T> &b) noexcept {
-	return !b;
-}
-template <typename T>
-inline bool operator!=(const unique_ptr<T> &a, std_::nullptr_t b) noexcept {
-	return !(a == b);
-}
-template <typename T>
-inline bool operator!=(std_::nullptr_t a, const unique_ptr<T> &b) noexcept {
-	return !(a == b);
-}
-
-using _yes = char(&)[1];
-using _no = char(&)[2];
-
-template <typename Base, typename Derived>
-struct _host {
-	operator Base*() const;
-	operator Derived*();
-};
-
-template <typename Base, typename Derived>
-struct is_base_of {
-	template <typename T>
-	static _yes check(Derived*, T);
-	static _no check(Base*, int);
-
-	static constexpr bool value = sizeof(check(_host<Base, Derived>(), int())) == sizeof(_yes);
-};
-
-inline void *align(size_t alignment, size_t size, void*& ptr, size_t& space) noexcept {
-#ifndef OS_MAC_OLD
-	using std::uintptr_t;
-#endif // OS_MAC_OLD
-
-	auto p = reinterpret_cast<uintptr_t>(ptr);
-	auto a = (p - 1u + alignment) & -alignment;
-	auto d = a - p;
-	if ((size + d) > space) {
-		return nullptr;
-	}
-	space -= d;
-	return ptr = reinterpret_cast<void*>(a);
-}
-
-} // namespace std_

Telegram/SourceFiles/core/task_queue.cpp

@@ -30,7 +30,7 @@ const auto MaxThreadsCount = qMax(QThread::idealThreadCount(), 2);
 template <typename Lambda>
 class Thread : public QThread {
 public:
-	Thread(Lambda code) : _code(std_::move(code)) {
+	Thread(Lambda code) : _code(std::move(code)) {
 	}
 	void run() override {
 		_code();
@@ -43,7 +43,7 @@ private:
 
 template <typename Lambda>
 object_ptr<Thread<Lambda>> MakeThread(Lambda code) {
-	return object_ptr<Thread<Lambda>>(std_::move(code));
+	return object_ptr<Thread<Lambda>>(std::move(code));
 }
 
 } // namespace
@@ -88,7 +88,7 @@ private:
 
 	void ThreadFunction();
 
-	std_::vector_of_moveable<object_ptr<QThread>> threads_;
+	std::vector<object_ptr<QThread>> threads_;
 	QMutex queues_mutex_;
 
 	// queues_mutex_ must be locked when working with the list.
@@ -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(new Task(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;
+		std::unique_ptr<Task> task;
 		{
 			QMutexLocker lock(&queues_mutex_);
 
@@ -344,12 +344,12 @@ TaskQueue::~TaskQueue() {
 void TaskQueue::Put(Task &&task) {
 	if (type_ == Type::Main) {
 		QMutexLocker lock(&tasks_mutex_);
-		tasks_.push_back(new Task(std_::move(task)));
+		tasks_.push_back(new Task(std::move(task)));
 
 		Sandbox::MainThreadTaskAdded();
 	} else {
 		t_assert(type_ != Type::Special);
-		TaskThreadPool::Instance()->AddQueueTask(this, std_::move(task));
+		TaskThreadPool::Instance()->AddQueueTask(this, std::move(task));
 	}
 }
 
@@ -372,7 +372,7 @@ void TaskQueue::ProcessMainTasks(TimeMs max_time_spent) { // static
 }
 
 bool TaskQueue::ProcessOneMainTask() { // static
-	std_::unique_ptr<Task> task;
+	std::unique_ptr<Task> task;
 	{
 		QMutexLocker lock(&Main().tasks_mutex_);
 		auto &tasks = Main().tasks_;

Telegram/SourceFiles/core/task_queue.h

@@ -69,7 +69,7 @@ private:
 	const Type type_;
 	const Priority priority_;
 
-	QList<Task*> tasks_; // TODO: std_::deque_of_moveable<Task>
+	QList<Task*> tasks_; // TODO: std::deque<Task>
 	QMutex tasks_mutex_; // Only for the main queue.
 
 	// Only for the other queues, not main.

Telegram/SourceFiles/core/type_traits.h

@@ -20,16 +20,14 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 */
 #pragma once
 
-#include "core/stl_subset.h"
-
 namespace base {
 
 template <typename T>
-struct custom_is_fast_copy_type : public std_::false_type {
+struct custom_is_fast_copy_type : public std::false_type {
 };
 // To make your own type a fast copy type just write:
 // template <>
-// struct base::custom_is_fast_copy_type<MyTinyType> : public std_::true_type {
+// struct base::custom_is_fast_copy_type<MyTinyType> : public std::true_type {
 // };
 
 namespace internal {
@@ -38,11 +36,11 @@ template <typename ...Types>
 struct type_list_contains;
 
 template <typename T>
-struct type_list_contains<T> : public std_::false_type {
+struct type_list_contains<T> : public std::false_type {
 };
 
 template <typename T, typename Head, typename ...Types>
-struct type_list_contains<T, Head, Types...> : public std_::integral_constant<bool, std_::is_same<Head, T>::value || type_list_contains<T, Types...>::value> {
+struct type_list_contains<T, Head, Types...> : public std::integral_constant<bool, std::is_same<Head, T>::value || type_list_contains<T, Types...>::value> {
 };
 
 template <typename T>
@@ -52,35 +50,35 @@ template <typename T>
 using is_std_signed_int = type_list_contains<T, signed char, short int, int, long int>;
 
 template <typename T>
-using is_std_integral = std_::integral_constant<bool, is_std_unsigned_int<T>::value || is_std_signed_int<T>::value || type_list_contains<T, bool, char, wchar_t>::value>;
+using is_std_integral = std::integral_constant<bool, is_std_unsigned_int<T>::value || is_std_signed_int<T>::value || type_list_contains<T, bool, char, wchar_t>::value>;
 
 template <typename T>
 using is_std_float = type_list_contains<T, float, double, long double>;
 
 template <typename T>
-using is_std_arith = std_::integral_constant<bool, is_std_integral<T>::value || is_std_float<T>::value>;
+using is_std_arith = std::integral_constant<bool, is_std_integral<T>::value || is_std_float<T>::value>;
 
 template <typename T>
-using is_std_fundamental = std_::integral_constant<bool, is_std_arith<T>::value || std_::is_same<T, void>::value>;
+using is_std_fundamental = std::integral_constant<bool, is_std_arith<T>::value || std::is_same<T, void>::value>;
 
 template <typename T>
-struct is_pointer : public std_::false_type {
+struct is_pointer : public std::false_type {
 };
 
 template <typename T>
-struct is_pointer<T*> : public std_::true_type {
+struct is_pointer<T*> : public std::true_type {
 };
 
 template <typename T>
-struct is_member_pointer : public std_::false_type {
+struct is_member_pointer : public std::false_type {
 };
 
 template <typename T, typename C>
-struct is_member_pointer<T C::*> : public std_::true_type {
+struct is_member_pointer<T C::*> : public std::true_type {
 };
 
 template <typename T>
-using is_fast_copy_type = std_::integral_constant<bool, is_std_fundamental<T>::value || is_pointer<T>::value || is_member_pointer<T>::value || custom_is_fast_copy_type<T>::value>;
+using is_fast_copy_type = std::integral_constant<bool, is_std_fundamental<T>::value || is_pointer<T>::value || is_member_pointer<T>::value || custom_is_fast_copy_type<T>::value>;
 
 template <typename T>
 struct add_const_reference {
@@ -122,7 +120,7 @@ struct type_traits {
 	using is_member_pointer = internal::is_member_pointer<T>;
 	using is_fast_copy_type = internal::is_fast_copy_type<T>;
 
-	using parameter_type = std_::conditional_t<is_fast_copy_type::value, T, internal::add_const_reference_t<T>>;
+	using parameter_type = std::conditional_t<is_fast_copy_type::value, T, internal::add_const_reference_t<T>>;
 	using pointed_type = internal::remove_pointer_t<T>;
 };
 

Telegram/SourceFiles/core/utils.h

@@ -31,40 +31,35 @@ inline constexpr size_t array_size(const T(&)[N]) {
 
 template <typename T>
 inline T take(T &source, T &&new_value = T()) {
-	std_::swap_moveable(new_value, source);
+	std::swap(new_value, source);
-	return std_::move(new_value);
+	return std::move(new_value);
 }
 
 namespace internal {
 
 template <typename D, typename T>
-inline constexpr D up_cast_helper(std_::true_type, T object) {
+inline constexpr D up_cast_helper(std::true_type, T object) {
 	return object;
 }
 
 template <typename D, typename T>
-inline constexpr D up_cast_helper(std_::false_type, T object) {
+inline constexpr D up_cast_helper(std::false_type, T object) {
 	return nullptr;
 }
 
-template <typename T>
-constexpr std_::add_const_t<T> &any_as_const(T &&value) noexcept {
-	return value;
-}
-
 } // namespace internal
 
 template <typename D, typename T>
 inline constexpr D up_cast(T object) {
-	using DV = std_::decay_simple_t<decltype(*D())>;
+	using DV = std::decay_t<decltype(*D())>;
-	using TV = std_::decay_simple_t<decltype(*T())>;
+	using TV = std::decay_t<decltype(*T())>;
-	return internal::up_cast_helper<D>(std_::integral_constant<bool, std_::is_base_of<DV, TV>::value || std_::is_same<DV, TV>::value>(), object);
+	return internal::up_cast_helper<D>(std::integral_constant<bool, std::is_base_of<DV, TV>::value || std::is_same<DV, TV>::value>(), object);
 }
 
 template <typename Lambda>
 class scope_guard_helper {
 public:
-	scope_guard_helper(Lambda on_scope_exit) : _handler(std_::move(on_scope_exit)) {
+	scope_guard_helper(Lambda on_scope_exit) : _handler(std::move(on_scope_exit)) {
 	}
 	void dismiss() {
 		_dismissed = true;
@@ -83,7 +78,7 @@ private:
 
 template <typename Lambda>
 scope_guard_helper<Lambda> scope_guard(Lambda on_scope_exit) {
-	return scope_guard_helper<Lambda>(std_::move(on_scope_exit));
+	return scope_guard_helper<Lambda>(std::move(on_scope_exit));
 }
 
 } // namespace base
@@ -92,7 +87,7 @@ scope_guard_helper<Lambda> scope_guard(Lambda on_scope_exit) {
 // it is important for the copy-on-write Qt containers
 // if you have "QVector<T*> v" then "for (T * const p : v)" will still call QVector::detach(),
 // while "for_const (T *p, v)" won't and "for_const (T *&p, v)" won't compile
-#define for_const(range_declaration, range_expression) for (range_declaration : base::internal::any_as_const(range_expression))
+#define for_const(range_declaration, range_expression) for (range_declaration : std::as_const(range_expression))
 
 template <typename Enum>
 inline QFlags<Enum> qFlags(Enum v) {
@@ -497,7 +492,7 @@ static int32 AlmostFullArcLength = (FullArcLength - MinArcLength);
 
 template <typename T, typename... Args>
 inline QSharedPointer<T> MakeShared(Args&&... args) {
-	return QSharedPointer<T>(new T(std_::forward<Args>(args)...));
+	return QSharedPointer<T>(new T(std::forward<Args>(args)...));
 }
 
 // This pointer is used for global non-POD variables that are allocated
@@ -512,7 +507,7 @@ public:
 	template <typename... Args>
 	void createIfNull(Args&&... args) {
 		if (isNull()) {
-			reset(new T(std_::forward<Args>(args)...));
+			reset(new T(std::forward<Args>(args)...));
 		}
 	};
 

Telegram/SourceFiles/core/vector_of_moveable.h

@@ -1,184 +0,0 @@
-/*
-This file is part of Telegram Desktop,
-the official desktop version of Telegram messaging app, see https://telegram.org
-
-Telegram Desktop is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-It is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-In addition, as a special exception, the copyright holders give permission
-to link the code of portions of this program with the OpenSSL library.
-
-Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
-Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
-*/
-#pragma once
-
-#include "core/stl_subset.h"
-
-// some minimal implementation of std::vector() for moveable (but not copiable) types.
-namespace std_ {
-
-template <typename T>
-class vector_of_moveable {
-	typedef vector_of_moveable<T> Self;
-	int _size = 0, _capacity = 0;
-	void *_plaindata = nullptr;
-
-public:
-	vector_of_moveable() = default;
-	vector_of_moveable(const vector_of_moveable &other) = delete;
-	vector_of_moveable &operator=(const vector_of_moveable &other) = delete;
-	vector_of_moveable(vector_of_moveable &&other)
-		: _size(base::take(other._size))
-		, _capacity(base::take(other._capacity))
-		, _plaindata(base::take(other._plaindata)) {
-	}
-	vector_of_moveable &operator=(vector_of_moveable &&other) {
-		std_::swap_moveable(_size, other._size);
-		std_::swap_moveable(_capacity, other._capacity);
-		std_::swap_moveable(_plaindata, other._plaindata);
-		return *this;
-	}
-
-	inline T *data() {
-		return reinterpret_cast<T*>(_plaindata);
-	}
-	inline const T *data() const {
-		return reinterpret_cast<const T*>(_plaindata);
-	}
-
-	inline bool operator==(const Self &other) const {
-		if (this == &other) return true;
-		if (_size != other._size) return false;
-		for (int i = 0; i < _size; ++i) {
-			if (data()[i] != other.data()[i]) {
-				return false;
-			}
-		}
-		return true;
-	}
-	inline bool operator!=(const Self &other) const { return !(*this == other); }
-	inline int size() const { return _size; }
-	inline bool isEmpty() const { return _size == 0; }
-	inline void clear() {
-		for (int i = 0; i < _size; ++i) {
-			data()[i].~T();
-		}
-		_size = 0;
-
-		operator delete[](_plaindata);
-		_plaindata = nullptr;
-		_capacity = 0;
-	}
-
-	typedef T *iterator;
-	typedef const T *const_iterator;
-
-	// STL style
-	inline iterator begin() { return data(); }
-	inline const_iterator begin() const { return data(); }
-	inline const_iterator cbegin() const { return data(); }
-	inline iterator end() { return data() + _size; }
-	inline const_iterator end() const { return data() + _size; }
-	inline const_iterator cend() const { return data() + _size; }
-	inline iterator erase(iterator it) {
-		T tmp = std_::move(*it);
-		for (auto next = it + 1, e = end(); next != e; ++next) {
-			auto prev = next - 1;
-			*prev = std_::move(*next);
-		}
-		--_size;
-		end()->~T();
-		return it;
-	}
-
-	inline iterator insert(const_iterator pos, T &&value) {
-		int insertAtIndex = pos - begin();
-		if (_size + 1 > _capacity) {
-			reallocate(_capacity + (_capacity > 1 ? _capacity / 2 : 1));
-		}
-		auto insertAt = begin() + insertAtIndex, e = end();
-		if (insertAt == e) {
-			new (&(*insertAt)) T(std_::move(value));
-		} else {
-			auto prev = e - 1;
-			new (&(*e)) T(std_::move(*prev));
-			for (auto it = prev; it != insertAt; --it) {
-				*it = std_::move(*--prev);
-			}
-			*insertAt = std_::move(value);
-		}
-		++_size;
-		return insertAt;
-	}
-	inline void push_back(T &&value) {
-		insert(end(), std_::move(value));
-	}
-	inline void pop_back() {
-		erase(end() - 1);
-	}
-	inline T &front() {
-		return *begin();
-	}
-	inline const T &front() const {
-		return *begin();
-	}
-	inline T &back() {
-		return *(end() - 1);
-	}
-	inline const T &back() const {
-		return *(end() - 1);
-	}
-	inline bool empty() const { return _size == 0; }
-
-	inline T &operator[](int index) {
-		return data()[index];
-	}
-	inline const T &operator[](int index) const {
-		return data()[index];
-	}
-	inline const T &at(int index) const {
-		if (index < 0 || index >= _size) {
-#ifndef OS_MAC_OLD
-			throw std::out_of_range("");
-#else // OS_MAC_OLD
-			throw std::exception();
-#endif // OS_MAC_OLD
-		}
-		return data()[index];
-	}
-
-	void reserve(int newCapacity) {
-		if (newCapacity > _capacity) {
-			reallocate(newCapacity);
-		}
-	}
-
-	inline ~vector_of_moveable() {
-		clear();
-	}
-
-private:
-	void reallocate(int newCapacity) {
-		auto newPlainData = operator new[](newCapacity * sizeof(T));
-		for (int i = 0; i < _size; ++i) {
-			auto oldLocation = data() + i;
-			auto newLocation = reinterpret_cast<T*>(newPlainData) + i;
-			new (newLocation) T(std_::move(*oldLocation));
-			oldLocation->~T();
-		}
-		std_::swap_moveable(_plaindata, newPlainData);
-		_capacity = newCapacity;
-		operator delete[](newPlainData);
-	}
-
-};
-
-} // namespace std_

Telegram/SourceFiles/core/virtual_method.h

@@ -233,9 +233,9 @@ typename virtual_object<Object, void>::virtual_object_registrator virtual_object
 namespace virtual_methods {
 
 template <typename Arg>
-struct is_virtual_argument : public std_::integral_constant<bool,
+struct is_virtual_argument : public std::integral_constant<bool,
 	base::type_traits<Arg>::is_pointer::value
-	? std_::is_base_of<object_base, typename base::type_traits<Arg>::pointed_type>::value
+	? std::is_base_of<object_base, typename base::type_traits<Arg>::pointed_type>::value
 	: false> {
 };
 
@@ -281,10 +281,10 @@ struct multi_index_collector<ConcreteArg, ConcreteArgs...> {
 		multi_index_collector<ConcreteArgs...>::call(indices.subindex(), args...);
 	}
 
-	static inline int computeIndex(std_::integral_constant<bool, false>, ConcreteArg arg) {
+	static inline int computeIndex(std::integral_constant<bool, false>, ConcreteArg arg) {
 		return 0;
 	}
-	static inline int computeIndex(std_::integral_constant<bool, true>, ConcreteArg arg) {
+	static inline int computeIndex(std::integral_constant<bool, true>, ConcreteArg arg) {
 		return arg->virtual_object_child_index();
 	}
 
@@ -348,15 +348,15 @@ public:
 		return (*this)[index.current()][index.subindex()];
 	}
 	inline int size() const {
-		return count_size(std_::integral_constant<int,N>());
+		return count_size(std::integral_constant<int,N>());
 	}
 
 private:
 	template <int M>
-	inline int count_size(std_::integral_constant<int,M>) const {
+	inline int count_size(std::integral_constant<int,M>) const {
 		return _size.current() / _size.subindex().current();
 	}
-	inline int count_size(std_::integral_constant<int,1>) const {
+	inline int count_size(std::integral_constant<int,1>) const {
 		return _size.current();
 	}
 
@@ -391,10 +391,10 @@ struct table_count_size<Arg, Args...> {
 		index.current() = count(is_virtual_argument<Arg>()) * subindex.current();
 	}
 
-	static inline int count(std_::integral_constant<bool, false>) {
+	static inline int count(std::integral_constant<bool, false>) {
 		return 1;
 	}
-	static inline int count(std_::integral_constant<bool, true>) {
+	static inline int count(std::integral_constant<bool, true>) {
 		return base::type_traits<Arg>::pointed_type::virtual_object_get_child_entries().size();
 	}
 
@@ -483,10 +483,10 @@ struct table_fill_entry_helper<Call, Arg, Args...> {
 		return false;
 	}
 
-	static inline bool good(std_::integral_constant<bool,false>, int start, int current) {
+	static inline bool good(std::integral_constant<bool,false>, int start, int current) {
 		return (start == current);
 	}
-	static inline bool good(std_::integral_constant<bool,true>, int start, int current) {
+	static inline bool good(std::integral_constant<bool,true>, int start, int current) {
 		using BaseObject = typename base::type_traits<Arg>::pointed_type;
 		auto &entries = BaseObject::virtual_object_get_child_entries();
 		return (start == current) || entries[start].check_is_parent(entries[current]);
@@ -531,10 +531,10 @@ struct override_key_collector_helper<M, ConcreteArg, ConcreteArgs...> {
 		override_key_collector_helper<M + 1, ConcreteArgs...>::call(indices);
 	}
 
-	static inline void setValue(std_::integral_constant<bool,false>, int **indices) {
+	static inline void setValue(std::integral_constant<bool,false>, int **indices) {
 		indices[M] = nullptr;
 	}
-	static inline void setValue(std_::integral_constant<bool,true>, int **indices) {
+	static inline void setValue(std::integral_constant<bool,true>, int **indices) {
 		using ConcreteObject = typename base::type_traits<ConcreteArg>::pointed_type;
 		using IsParentCheckStruct = is_parent<ConcreteObject>;
 		using IsParentCheckPointer = decltype(&IsParentCheckStruct::check);

Telegram/SourceFiles/data/data_drafts.cpp

@@ -44,10 +44,10 @@ void applyPeerCloudDraft(PeerId peerId, const MTPDdraftMessage &draft) {
 	auto entities = draft.has_entities() ? entitiesFromMTP(draft.ventities.c_vector().v) : EntitiesInText();
 	TextWithTags textWithTags = { textApplyEntities(text, entities), textTagsFromEntities(entities) };
 	MsgId replyTo = draft.has_reply_to_msg_id() ? draft.vreply_to_msg_id.v : 0;
-	auto cloudDraft = std_::make_unique<Draft>(textWithTags, replyTo, MessageCursor(QFIXED_MAX, QFIXED_MAX, QFIXED_MAX), draft.is_no_webpage());
+	auto cloudDraft = std::make_unique<Draft>(textWithTags, replyTo, MessageCursor(QFIXED_MAX, QFIXED_MAX, QFIXED_MAX), draft.is_no_webpage());
 	cloudDraft->date = ::date(draft.vdate);
 
-	history->setCloudDraft(std_::move(cloudDraft));
+	history->setCloudDraft(std::move(cloudDraft));
 	history->createLocalDraftFromCloud();
 	history->updateChatListSortPosition();
 

Telegram/SourceFiles/dialogs/dialogs_list.cpp

@@ -28,7 +28,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 namespace Dialogs {
 
 List::List(SortMode sortMode)
-: _last(std_::make_unique<Row>(nullptr, nullptr, nullptr, 0))
+: _last(std::make_unique<Row>(nullptr, nullptr, nullptr, 0))
 , _begin(_last.get())
 , _end(_last.get())
 , _sortMode(sortMode)

Telegram/SourceFiles/dialogs/dialogs_list.h

@@ -121,7 +121,7 @@ private:
 		return row->_prev;
 	}
 
-	std_::unique_ptr<Row> _last;
+	std::unique_ptr<Row> _last;
 	Row *_begin;
 	Row *_end;
 	SortMode _sortMode;

Telegram/SourceFiles/dialogs/dialogs_row.cpp

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

Telegram/SourceFiles/dialogs/dialogs_row.h

@@ -45,7 +45,7 @@ public:
 	void paintRipple(Painter &p, int x, int y, int outerWidth, TimeMs ms, const QColor *colorOverride = nullptr) const;
 
 private:
-	mutable std_::unique_ptr<Ui::RippleAnimation> _ripple;
+	mutable std::unique_ptr<Ui::RippleAnimation> _ripple;
 
 };
 

Telegram/SourceFiles/dialogswidget.cpp

@@ -72,9 +72,9 @@ struct DialogsInner::PeerSearchResult {
 };
 
 DialogsInner::DialogsInner(QWidget *parent, QWidget *main) : SplittedWidget(parent)
-, _dialogs(std_::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Date))
+, _dialogs(std::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Date))
-, _contactsNoDialogs(std_::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Name))
+, _contactsNoDialogs(std::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Name))
-, _contacts(std_::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Name))
+, _contacts(std::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Name))
 , _a_pinnedShifting(animation(this, &DialogsInner::step_pinnedShifting))
 , _addContactLnk(this, lang(lng_add_contact_button))
 , _cancelSearchInPeer(this, st::dialogsCancelSearchInPeer) {
@@ -85,8 +85,8 @@ DialogsInner::DialogsInner(QWidget *parent, QWidget *main) : SplittedWidget(pare
 #endif // OS_MAC_OLD
 
 	if (Global::DialogsModeEnabled()) {
-		_dialogsImportant = std_::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Date);
+		_dialogsImportant = std::make_unique<Dialogs::IndexedList>(Dialogs::SortMode::Date);
-		_importantSwitch = std_::make_unique<ImportantSwitch>();
+		_importantSwitch = std::make_unique<ImportantSwitch>();
 	}
 	connect(main, SIGNAL(peerNameChanged(PeerData*, const PeerData::Names&, const PeerData::NameFirstChars&)), this, SLOT(onPeerNameChanged(PeerData*, const PeerData::Names&, const PeerData::NameFirstChars&)));
 	connect(main, SIGNAL(peerPhotoChanged(PeerData*)), this, SLOT(onPeerPhotoChanged(PeerData*)));
@@ -130,7 +130,7 @@ int DialogsInner::peerSearchOffset() const {
 }
 
 int DialogsInner::searchedOffset() const {
-	int result = peerSearchOffset() + (_peerSearchResults.isEmpty() ? 0 : ((_peerSearchResults.size() * st::dialogsRowHeight) + st::searchedBarHeight));
+	int result = peerSearchOffset() + (_peerSearchResults.empty() ? 0 : ((_peerSearchResults.size() * st::dialogsRowHeight) + st::searchedBarHeight));
 	if (_searchInPeer) result += st::dialogsRowHeight;
 	return result;
 }
@@ -162,7 +162,7 @@ void DialogsInner::paintRegion(Painter &p, const QRegion &region, bool paintingO
 		auto active = App::main()->activePeer();
 		auto selected = _menuPeer ? _menuPeer : (isPressed() ? (_pressed ? _pressed->history()->peer : nullptr) : (_selected ? _selected->history()->peer : nullptr));
 		if (otherStart) {
-			auto reorderingPinned = (_aboveIndex >= 0 && !_pinnedRows.isEmpty());
+			auto reorderingPinned = (_aboveIndex >= 0 && !_pinnedRows.empty());
 			auto &list = rows->all();
 			if (reorderingPinned) {
 				dialogsClip = dialogsClip.marginsAdded(QMargins(0, st::dialogsRowHeight, 0, st::dialogsRowHeight));
@@ -214,7 +214,7 @@ void DialogsInner::paintRegion(Painter &p, const QRegion &region, bool paintingO
 			}
 		}
 	} else if (_state == FilteredState || _state == SearchedState) {
-		if (!_hashtagResults.isEmpty()) {
+		if (!_hashtagResults.empty()) {
 			int32 from = floorclamp(r.y(), st::mentionHeight, 0, _hashtagResults.size());
 			int32 to = ceilclamp(r.y() + r.height(), st::mentionHeight, 0, _hashtagResults.size());
 			p.translate(0, from * st::mentionHeight);
@@ -279,7 +279,7 @@ void DialogsInner::paintRegion(Painter &p, const QRegion &region, bool paintingO
 			}
 		}
 
-		if (!_peerSearchResults.isEmpty()) {
+		if (!_peerSearchResults.empty()) {
 			p.fillRect(0, 0, fullWidth, st::searchedBarHeight, st::searchedBarBg);
 			if (!paintingOther) {
 				p.setFont(st::searchedBarFont);
@@ -309,7 +309,7 @@ void DialogsInner::paintRegion(Painter &p, const QRegion &region, bool paintingO
 		if (_searchInPeer) {
 			paintSearchInPeer(p, fullWidth, paintingOther);
 			p.translate(0, st::dialogsRowHeight);
-			if (_state == FilteredState && _searchResults.isEmpty()) {
+			if (_state == FilteredState && _searchResults.empty()) {
 				p.fillRect(0, 0, fullWidth, st::searchedBarHeight, st::searchedBarBg);
 				if (!paintingOther) {
 					p.setFont(st::searchedBarFont);
@@ -320,8 +320,8 @@ void DialogsInner::paintRegion(Painter &p, const QRegion &region, bool paintingO
 			}
 		}
 
-		if (_state == SearchedState || !_searchResults.isEmpty()) {
+		if (_state == SearchedState || !_searchResults.empty()) {
-			QString text = lng_search_found_results(lt_count, _searchResults.isEmpty() ? 0 : (_searchedMigratedCount + _searchedCount));
+			QString text = lng_search_found_results(lt_count, _searchResults.empty() ? 0 : (_searchedMigratedCount + _searchedCount));
 			p.fillRect(0, 0, fullWidth, st::searchedBarHeight, st::searchedBarBg);
 			if (!paintingOther) {
 				p.setFont(st::searchedBarFont);
@@ -491,7 +491,7 @@ void DialogsInner::updateSelected(QPoint localPos) {
 		}
 	} else if (_state == FilteredState || _state == SearchedState) {
 		auto wasSelected = isSelected();
-		if (_hashtagResults.isEmpty()) {
+		if (_hashtagResults.empty()) {
 			_hashtagSelected = -1;
 			_hashtagDeleteSelected = false;
 		} else {
@@ -519,7 +519,7 @@ void DialogsInner::updateSelected(QPoint localPos) {
 				updateSelectedRow();
 			}
 		}
-		if (!_peerSearchResults.isEmpty()) {
+		if (!_peerSearchResults.empty()) {
 			auto skip = peerSearchOffset();
 			auto peerSearchSelected = (mouseY >= skip) ? ((mouseY - skip) / st::dialogsRowHeight) : -1;
 			if (peerSearchSelected < 0 || peerSearchSelected >= _peerSearchResults.size()) {
@@ -531,7 +531,7 @@ void DialogsInner::updateSelected(QPoint localPos) {
 				updateSelectedRow();
 			}
 		}
-		if (_state == SearchedState && !_searchResults.isEmpty()) {
+		if (_state == SearchedState && !_searchResults.empty()) {
 			auto skip = searchedOffset();
 			auto searchedSelected = (mouseY >= skip) ? ((mouseY - skip) / st::dialogsRowHeight) : -1;
 			if (searchedSelected < 0 || searchedSelected >= _searchResults.size()) {
@@ -718,7 +718,7 @@ bool DialogsInner::updateReorderPinned(QPoint localPosition) {
 		shift = -floorclamp(_dragStart.y() - localPosition.y() + (rowHeight / 2), rowHeight, 0, _draggingIndex);
 		for (auto from = _draggingIndex, to = _draggingIndex + shift; from > to; --from) {
 			shownDialogs()->movePinned(_dragging, -1);
-			std_::swap_moveable(_pinnedRows[from], _pinnedRows[from - 1]);
+			std::swap(_pinnedRows[from], _pinnedRows[from - 1]);
 			_pinnedRows[from].yadd = anim::value(_pinnedRows[from].yadd.current() - rowHeight, 0);
 			_pinnedRows[from].animStartTime = ms;
 		}
@@ -726,7 +726,7 @@ bool DialogsInner::updateReorderPinned(QPoint localPosition) {
 		shift = floorclamp(localPosition.y() - _dragStart.y() + (rowHeight / 2), rowHeight, 0, pinnedCount - _draggingIndex - 1);
 		for (auto from = _draggingIndex, to = _draggingIndex + shift; from < to; ++from) {
 			shownDialogs()->movePinned(_dragging, 1);
-			std_::swap_moveable(_pinnedRows[from], _pinnedRows[from + 1]);
+			std::swap(_pinnedRows[from], _pinnedRows[from + 1]);
 			_pinnedRows[from].yadd = anim::value(_pinnedRows[from].yadd.current() + rowHeight, 0);
 			_pinnedRows[from].animStartTime = ms;
 		}
@@ -761,7 +761,7 @@ void DialogsInner::step_pinnedShifting(TimeMs ms, bool timer) {
 	auto animating = false;
 	auto updateMin = -1;
 	auto updateMax = 0;
-	for (auto i = 0, l = _pinnedRows.size(); i != l; ++i) {
+	for (auto i = 0, l = static_cast<int>(_pinnedRows.size()); i != l; ++i) {
 		auto start = _pinnedRows[i].animStartTime;
 		if (start) {
 			if (updateMin < 0) updateMin = i;
@@ -1065,7 +1065,7 @@ void DialogsInner::updateDialogRow(PeerData *peer, MsgId msgId, QRect updateRect
 				++index;
 			}
 		}
-		if ((sections & UpdateRowSection::PeerSearch) && !_peerSearchResults.isEmpty()) {
+		if ((sections & UpdateRowSection::PeerSearch) && !_peerSearchResults.empty()) {
 			auto index = 0, add = peerSearchOffset();
 			for_const (auto &result, _peerSearchResults) {
 				if (result->peer == peer) {
@@ -1075,7 +1075,7 @@ void DialogsInner::updateDialogRow(PeerData *peer, MsgId msgId, QRect updateRect
 				++index;
 			}
 		}
-		if ((sections & UpdateRowSection::MessageSearch) && !_searchResults.isEmpty()) {
+		if ((sections & UpdateRowSection::MessageSearch) && !_searchResults.empty()) {
 			auto index = 0, add = searchedOffset();
 			for_const (auto &result, _searchResults) {
 				auto item = result->item();
@@ -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) {
-		return _menu->addAction(text, std_::move(callback));
+		return _menu->addAction(text, std::move(callback));
 	}, true);
 	connect(_menu, SIGNAL(destroyed(QObject*)), this, SLOT(onMenuDestroyed(QObject*)));
 	_menu->popup(e->globalPos());
@@ -1343,7 +1343,7 @@ void DialogsInner::onFilterUpdate(QString newFilter, bool force) {
 void DialogsInner::onHashtagFilterUpdate(QStringRef newFilter) {
 	if (newFilter.isEmpty() || newFilter.at(0) != '#' || _searchInPeer) {
 		_hashtagFilter = QString();
-		if (!_hashtagResults.isEmpty()) {
+		if (!_hashtagResults.empty()) {
 			_hashtagResults.clear();
 			refresh(true);
 			setMouseSelection(false, true);
@@ -1360,7 +1360,7 @@ void DialogsInner::onHashtagFilterUpdate(QStringRef newFilter) {
 		_hashtagResults.reserve(qMin(recent.size(), kHashtagResultsLimit));
 		for (auto i = recent.cbegin(), e = recent.cend(); i != e; ++i) {
 			if (i->first.startsWith(_hashtagFilter.midRef(1), Qt::CaseInsensitive) && i->first.size() + 1 != newFilter.size()) {
-				_hashtagResults.push_back(std_::make_unique<HashtagResult>(i->first));
+				_hashtagResults.push_back(std::make_unique<HashtagResult>(i->first));
 				if (_hashtagResults.size() == kHashtagResultsLimit) break;
 			}
 		}
@@ -1505,7 +1505,7 @@ bool DialogsInner::searchReceived(const QVector<MTPMessage> &messages, DialogsSe
 			if (auto peer = App::peerLoaded(peerId)) {
 				if (lastDate) {
 					auto item = App::histories().addNewMessage(message, NewMessageExisting);
-					_searchResults.push_back(std_::make_unique<Dialogs::FakeRow>(item));
+					_searchResults.push_back(std::make_unique<Dialogs::FakeRow>(item));
 					lastDateFound = lastDate;
 					if (isGlobalSearch) {
 						_lastSearchDate = lastDateFound;
@@ -1531,7 +1531,7 @@ bool DialogsInner::searchReceived(const QVector<MTPMessage> &messages, DialogsSe
 	} else {
 		_searchedCount = fullCount;
 	}
-	if (_state == FilteredState && (!_searchResults.isEmpty() || !_searchInMigrated || type == DialogsSearchMigratedFromStart || type == DialogsSearchMigratedFromOffset)) {
+	if (_state == FilteredState && (!_searchResults.empty() || !_searchInMigrated || type == DialogsSearchMigratedFromStart || type == DialogsSearchMigratedFromOffset)) {
 		_state = SearchedState;
 	}
 	refresh();
@@ -1550,7 +1550,7 @@ void DialogsInner::peerSearchReceived(const QString &query, const QVector<MTPPee
 			}
 		}
 		if (auto peer = App::peerLoaded(peerId)) {
-			_peerSearchResults.push_back(std_::make_unique<PeerSearchResult>(App::peer(peerId)));
+			_peerSearchResults.push_back(std::make_unique<PeerSearchResult>(App::peer(peerId)));
 		} else {
 			LOG(("API Error: user %1 was not loaded in DialogsInner::peopleReceived()").arg(peerId));
 		}
@@ -1660,7 +1660,7 @@ void DialogsInner::refresh(bool toTop) {
 	} else {
 		if (!_addContactLnk->isHidden()) _addContactLnk->hide();
 		if (_state == FilteredState) {
-			h = searchedOffset() + (_searchResults.size() * st::dialogsRowHeight) + ((_searchResults.isEmpty() && !_searchInPeer) ? -st::searchedBarHeight : 0);
+			h = searchedOffset() + (_searchResults.size() * st::dialogsRowHeight) + ((_searchResults.empty() && !_searchInPeer) ? -st::searchedBarHeight : 0);
 		} else if (_state == SearchedState) {
 			h = searchedOffset() + (_searchResults.size() * st::dialogsRowHeight);
 		}
@@ -1707,7 +1707,7 @@ DialogsInner::State DialogsInner::state() const {
 }
 
 bool DialogsInner::hasFilteredResults() const {
-	return !_filterResults.isEmpty() && _hashtagResults.isEmpty();
+	return !_filterResults.isEmpty() && _hashtagResults.empty();
 }
 
 void DialogsInner::searchInPeer(PeerData *peer) {
@@ -1777,23 +1777,23 @@ void DialogsInner::selectSkip(int32 direction) {
 			emit mustScrollTo(fromY, fromY + st::dialogsRowHeight);
 		}
 	} else if (_state == FilteredState || _state == SearchedState) {
-		if (_hashtagResults.isEmpty() && _filterResults.isEmpty() && _peerSearchResults.isEmpty() && _searchResults.isEmpty()) return;
+		if (_hashtagResults.empty() && _filterResults.isEmpty() && _peerSearchResults.empty() && _searchResults.empty()) return;
 		if ((_hashtagSelected < 0 || _hashtagSelected >= _hashtagResults.size()) &&
 			(_filteredSelected < 0 || _filteredSelected >= _filterResults.size()) &&
 			(_peerSearchSelected < 0 || _peerSearchSelected >= _peerSearchResults.size()) &&
 			(_searchedSelected < 0 || _searchedSelected >= _searchResults.size())) {
-			if (_hashtagResults.isEmpty() && _filterResults.isEmpty() && _peerSearchResults.isEmpty()) {
+			if (_hashtagResults.empty() && _filterResults.isEmpty() && _peerSearchResults.empty()) {
 				_searchedSelected = 0;
-			} else if (_hashtagResults.isEmpty() && _filterResults.isEmpty()) {
+			} else if (_hashtagResults.empty() && _filterResults.isEmpty()) {
 				_peerSearchSelected = 0;
-			} else if (_hashtagResults.isEmpty()) {
+			} else if (_hashtagResults.empty()) {
 				_filteredSelected = 0;
 			} else {
 				_hashtagSelected = 0;
 			}
 		} else {
 			int32 cur = (_hashtagSelected >= 0 && _hashtagSelected < _hashtagResults.size()) ? _hashtagSelected : ((_filteredSelected >= 0 && _filteredSelected < _filterResults.size()) ? (_hashtagResults.size() + _filteredSelected) : ((_peerSearchSelected >= 0 && _peerSearchSelected < _peerSearchResults.size()) ? (_peerSearchSelected + _filterResults.size() + _hashtagResults.size()) : (_searchedSelected + _peerSearchResults.size() + _filterResults.size() + _hashtagResults.size())));
-			cur = snap(cur + direction, 0, _hashtagResults.size() + _filterResults.size() + _peerSearchResults.size() + _searchResults.size() - 1);
+			cur = snap(cur + direction, 0, static_cast<int>(_hashtagResults.size() + _filterResults.size() + _peerSearchResults.size() + _searchResults.size()) - 1);
 			if (cur < _hashtagResults.size()) {
 				_hashtagSelected = cur;
 				_filteredSelected = _peerSearchSelected = _searchedSelected = -1;
@@ -1926,10 +1926,10 @@ void DialogsInner::loadPeerPhotos() {
 				_peerSearchResults[from]->peer->loadUserpic();
 			}
 		}
-		from = (yFrom > filteredOffset() + ((_peerSearchResults.isEmpty() ? 0 : st::searchedBarHeight) + st::searchedBarHeight) ? ((yFrom - filteredOffset() - (_peerSearchResults.isEmpty() ? 0 : st::searchedBarHeight) - st::searchedBarHeight) / int32(st::dialogsRowHeight)) : 0) - _filterResults.size() - _peerSearchResults.size();
+		from = (yFrom > filteredOffset() + ((_peerSearchResults.empty() ? 0 : st::searchedBarHeight) + st::searchedBarHeight) ? ((yFrom - filteredOffset() - (_peerSearchResults.empty() ? 0 : st::searchedBarHeight) - st::searchedBarHeight) / int32(st::dialogsRowHeight)) : 0) - _filterResults.size() - _peerSearchResults.size();
 		if (from < 0) from = 0;
 		if (from < _searchResults.size()) {
-			int32 to = (yTo > filteredOffset() + (_peerSearchResults.isEmpty() ? 0 : st::searchedBarHeight) + st::searchedBarHeight ? ((yTo - filteredOffset() - (_peerSearchResults.isEmpty() ? 0 : st::searchedBarHeight) - st::searchedBarHeight) / int32(st::dialogsRowHeight)) : 0) - _filterResults.size() - _peerSearchResults.size() + 1, w = width();
+			int32 to = (yTo > filteredOffset() + (_peerSearchResults.empty() ? 0 : st::searchedBarHeight) + st::searchedBarHeight ? ((yTo - filteredOffset() - (_peerSearchResults.empty() ? 0 : st::searchedBarHeight) - st::searchedBarHeight) / int32(st::dialogsRowHeight)) : 0) - _filterResults.size() - _peerSearchResults.size() + 1, w = width();
 			if (to > _searchResults.size()) to = _searchResults.size();
 
 			for (; from < to; ++from) {
@@ -2071,7 +2071,7 @@ void DialogsInner::peerBefore(const PeerData *inPeer, MsgId inMsg, PeerData *&ou
 		outMsg = 0;
 		return;
 	} else if (_state == FilteredState || _state == SearchedState) {
-		if (inMsg && !_searchResults.isEmpty()) {
+		if (inMsg && !_searchResults.empty()) {
 			for (auto b = _searchResults.cbegin(), i = b + 1, e = _searchResults.cend(); i != e; ++i) {
 				if ((*i)->item()->history()->peer == inPeer && (*i)->item()->id == inMsg) {
 					auto j = i - 1;
@@ -2082,7 +2082,7 @@ void DialogsInner::peerBefore(const PeerData *inPeer, MsgId inMsg, PeerData *&ou
 			}
 			if (_searchResults.at(0)->item()->history()->peer == inPeer && _searchResults.at(0)->item()->id == inMsg) {
 				outMsg = ShowAtUnreadMsgId;
-				if (_peerSearchResults.isEmpty()) {
+				if (_peerSearchResults.empty()) {
 					if (_filterResults.isEmpty()) {
 						outPeer = nullptr;
 					} else {
@@ -2094,12 +2094,12 @@ void DialogsInner::peerBefore(const PeerData *inPeer, MsgId inMsg, PeerData *&ou
 				return;
 			}
 		}
-		if (!_peerSearchResults.isEmpty() && _peerSearchResults[0]->peer == inPeer) {
+		if (!_peerSearchResults.empty() && _peerSearchResults[0]->peer == inPeer) {
 			outPeer = _filterResults.isEmpty() ? 0 : _filterResults.back()->history()->peer;
 			outMsg = ShowAtUnreadMsgId;
 			return;
 		}
-		if (!_peerSearchResults.isEmpty()) {
+		if (!_peerSearchResults.empty()) {
 			for (auto b = _peerSearchResults.cbegin(), i = b + 1, e = _peerSearchResults.cend(); i != e; ++i) {
 				if ((*i)->peer == inPeer) {
 					outPeer = (*(i - 1))->peer;
@@ -2158,7 +2158,7 @@ void DialogsInner::peerAfter(const PeerData *inPeer, MsgId inMsg, PeerData *&out
 		for (auto i = _peerSearchResults.cbegin(), e = _peerSearchResults.cend(); i != e; ++i) {
 			if ((*i)->peer == inPeer) {
 				++i;
-				if (i == e && !_searchResults.isEmpty()) {
+				if (i == e && !_searchResults.empty()) {
 					outPeer = _searchResults.front()->item()->history()->peer;
 					outMsg = _searchResults.front()->item()->id;
 				} else {
@@ -2171,10 +2171,10 @@ void DialogsInner::peerAfter(const PeerData *inPeer, MsgId inMsg, PeerData *&out
 		for (FilteredDialogs::const_iterator i = _filterResults.cbegin(), e = _filterResults.cend(); i != e; ++i) {
 			if ((*i)->history()->peer == inPeer) {
 				++i;
-				if (i == e && !_peerSearchResults.isEmpty()) {
+				if (i == e && !_peerSearchResults.empty()) {
 					outPeer = _peerSearchResults.front()->peer;
 					outMsg = ShowAtUnreadMsgId;
-				} else if (i == e && !_searchResults.isEmpty()) {
+				} else if (i == e && !_searchResults.empty()) {
 					outPeer = _searchResults.front()->item()->history()->peer;
 					outMsg = _searchResults.front()->item()->id;
 				} else {

Telegram/SourceFiles/dialogswidget.h

@@ -113,7 +113,7 @@ public:
 	PeerData *updateFromParentDrag(QPoint globalPos);
 
 	void setLoadMoreCallback(base::lambda<void()> &&callback) {
-		_loadMoreCallback = std_::move(callback);
+		_loadMoreCallback = std::move(callback);
 	}
 	void setVisibleTopBottom(int visibleTop, int visibleBottom) override;
 
@@ -152,13 +152,13 @@ protected:
 
 private:
 	struct ImportantSwitch;
-	using DialogsList = std_::unique_ptr<Dialogs::IndexedList>;
+	using DialogsList = std::unique_ptr<Dialogs::IndexedList>;
 	using FilteredDialogs = QVector<Dialogs::Row*>;
-	using SearchResults = std_::vector_of_moveable<std_::unique_ptr<Dialogs::FakeRow>>;
+	using SearchResults = std::vector<std::unique_ptr<Dialogs::FakeRow>>;
 	struct HashtagResult;
-	using HashtagResults = std_::vector_of_moveable<std_::unique_ptr<HashtagResult>>;
+	using HashtagResults = std::vector<std::unique_ptr<HashtagResult>>;
 	struct PeerSearchResult;
-	using PeerSearchResults = std_::vector_of_moveable<std_::unique_ptr<PeerSearchResult>>;
+	using PeerSearchResults = std::vector<std::unique_ptr<PeerSearchResult>>;
 
 	void mousePressReleased(Qt::MouseButton button);
 	void clearIrrelevantState();
@@ -228,7 +228,7 @@ private:
 	bool _mouseSelection = false;
 	Qt::MouseButton _pressButton = Qt::LeftButton;
 
-	std_::unique_ptr<ImportantSwitch> _importantSwitch;
+	std::unique_ptr<ImportantSwitch> _importantSwitch;
 	bool _importantSwitchSelected = false;
 	bool _importantSwitchPressed = false;
 	Dialogs::Row *_selected = nullptr;
@@ -242,7 +242,7 @@ private:
 		anim::value yadd;
 		TimeMs animStartTime = 0;
 	};
-	std_::vector_of_moveable<PinnedRow> _pinnedRows;
+	std::vector<PinnedRow> _pinnedRows;
 	BasicAnimation _a_pinnedShifting;
 	QList<History*> _pinnedOrder;
 

Telegram/SourceFiles/facades.cpp

@@ -21,7 +21,6 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include "stdafx.h"
 
 #include "profile/profile_section_memento.h"
-#include "core/vector_of_moveable.h"
 #include "core/click_handler_types.h"
 #include "observer_peer.h"
 #include "mainwindow.h"
@@ -40,7 +39,7 @@ namespace App {
 namespace internal {
 
 void CallDelayed(int duration, base::lambda<void()> &&lambda) {
-	QTimer::singleShot(duration, base::lambda_slot_once(App::app(), std_::move(lambda)), SLOT(action()));
+	QTimer::singleShot(duration, base::lambda_slot_once(App::app(), std::move(lambda)), SLOT(action()));
 }
 
 } // namespace internal
@@ -204,7 +203,7 @@ namespace internal {
 
 void showBox(object_ptr<BoxContent> content, ShowLayerOptions options) {
 	if (auto w = App::wnd()) {
-		w->ui_showBox(std_::move(content), options);
+		w->ui_showBox(std::move(content), options);
 	}
 }
 

Telegram/SourceFiles/facades.h

@@ -41,19 +41,19 @@ void CallDelayed(int duration, base::lambda<void()> &&lambda);
 
 template <int N, typename Lambda>
 inline void CallDelayed(int duration, base::internal::lambda_guard<N, Lambda> &&guarded) {
-	return internal::CallDelayed(duration, [guarded = std_::move(guarded)] { guarded(); });
+	return internal::CallDelayed(duration, [guarded = std::move(guarded)] { guarded(); });
 }
 
 template <typename Pointer, typename ...PointersAndLambda>
 inline void CallDelayed(int duration, Pointer &&qobject, PointersAndLambda&&... qobjectsAndLambda) {
-	auto guarded = base::lambda_guarded(std_::forward<Pointer>(qobject), std_::forward<PointersAndLambda>(qobjectsAndLambda)...);
+	auto guarded = base::lambda_guarded(std::forward<Pointer>(qobject), std::forward<PointersAndLambda>(qobjectsAndLambda)...);
-	return CallDelayed(duration, std_::move(guarded));
+	return CallDelayed(duration, std::move(guarded));
 }
 
 template <typename ...PointersAndLambda>
 inline base::lambda<void()> LambdaDelayed(int duration, PointersAndLambda&&... qobjectsAndLambda) {
-	auto guarded = base::lambda_guarded(std_::forward<PointersAndLambda>(qobjectsAndLambda)...);
+	auto guarded = base::lambda_guarded(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
-	return [guarded = std_::move(guarded), duration] {
+	return [guarded = std::move(guarded), duration] {
 		CallDelayed(duration, guarded.clone());
 	};
 }
@@ -90,7 +90,7 @@ void hideMediaPreview();
 template <typename BoxType>
 QPointer<BoxType> show(object_ptr<BoxType> content, ShowLayerOptions options = CloseOtherLayers) {
 	auto result = QPointer<BoxType>(content.data());
-	internal::showBox(std_::move(content), options);
+	internal::showBox(std::move(content), options);
 	return result;
 }
 
@@ -209,7 +209,7 @@ inline bool IsTopCorner(ScreenCorner corner) {
 namespace base {
 
 template <>
-struct custom_is_fast_copy_type<Notify::ChangeType> : public std_::true_type {
+struct custom_is_fast_copy_type<Notify::ChangeType> : public std::true_type {
 };
 
 } // namespace base

Telegram/SourceFiles/history.cpp

@@ -106,14 +106,14 @@ void History::setHasPendingResizedItems() {
 	Global::RefHandleHistoryUpdate().call();
 }
 
-void History::setLocalDraft(std_::unique_ptr<Data::Draft> &&draft) {
+void History::setLocalDraft(std::unique_ptr<Data::Draft> &&draft) {
-	_localDraft = std_::move(draft);
+	_localDraft = std::move(draft);
 }
 
 void History::takeLocalDraft(History *from) {
 	if (auto &draft = from->_localDraft) {
 		if (!draft->textWithTags.text.isEmpty() && !_localDraft) {
-			_localDraft = std_::move(draft);
+			_localDraft = std::move(draft);
 
 			// Edit and reply to drafts can't migrate.
 			// Cloud drafts do not migrate automatically.
@@ -131,7 +131,7 @@ void History::createLocalDraftFromCloud() {
 	auto existing = localDraft();
 	if (Data::draftIsNull(existing) || !existing->date.isValid() || draft->date >= existing->date) {
 		if (!existing) {
-			setLocalDraft(std_::make_unique<Data::Draft>(draft->textWithTags, draft->msgId, draft->cursor, draft->previewCancelled));
+			setLocalDraft(std::make_unique<Data::Draft>(draft->textWithTags, draft->msgId, draft->cursor, draft->previewCancelled));
 			existing = localDraft();
 		} else if (existing != draft) {
 			existing->textWithTags = draft->textWithTags;
@@ -143,19 +143,19 @@ void History::createLocalDraftFromCloud() {
 	}
 }
 
-void History::setCloudDraft(std_::unique_ptr<Data::Draft> &&draft) {
+void History::setCloudDraft(std::unique_ptr<Data::Draft> &&draft) {
-	_cloudDraft = std_::move(draft);
+	_cloudDraft = std::move(draft);
 	cloudDraftTextCache.clear();
 }
 
 Data::Draft *History::createCloudDraft(Data::Draft *fromDraft) {
 	if (Data::draftIsNull(fromDraft)) {
-		setCloudDraft(std_::make_unique<Data::Draft>(TextWithTags(), 0, MessageCursor(), false));
+		setCloudDraft(std::make_unique<Data::Draft>(TextWithTags(), 0, MessageCursor(), false));
 		cloudDraft()->date = QDateTime();
 	} else {
 		auto existing = cloudDraft();
 		if (!existing) {
-			setCloudDraft(std_::make_unique<Data::Draft>(fromDraft->textWithTags, fromDraft->msgId, fromDraft->cursor, fromDraft->previewCancelled));
+			setCloudDraft(std::make_unique<Data::Draft>(fromDraft->textWithTags, fromDraft->msgId, fromDraft->cursor, fromDraft->previewCancelled));
 			existing = cloudDraft();
 		} else if (existing != fromDraft) {
 			existing->textWithTags = fromDraft->textWithTags;
@@ -172,8 +172,8 @@ Data::Draft *History::createCloudDraft(Data::Draft *fromDraft) {
 	return cloudDraft();
 }
 
-void History::setEditDraft(std_::unique_ptr<Data::Draft> &&draft) {
+void History::setEditDraft(std::unique_ptr<Data::Draft> &&draft) {
-	_editDraft = std_::move(draft);
+	_editDraft = std::move(draft);
 }
 
 void History::clearLocalDraft() {

Telegram/SourceFiles/history.h

@@ -378,12 +378,12 @@ public:
 	Data::Draft *editDraft() {
 		return _editDraft.get();
 	}
-	void setLocalDraft(std_::unique_ptr<Data::Draft> &&draft);
+	void setLocalDraft(std::unique_ptr<Data::Draft> &&draft);
 	void takeLocalDraft(History *from);
 	void createLocalDraftFromCloud();
-	void setCloudDraft(std_::unique_ptr<Data::Draft> &&draft);
+	void setCloudDraft(std::unique_ptr<Data::Draft> &&draft);
 	Data::Draft *createCloudDraft(Data::Draft *fromDraft);
-	void setEditDraft(std_::unique_ptr<Data::Draft> &&draft);
+	void setEditDraft(std::unique_ptr<Data::Draft> &&draft);
 	void clearLocalDraft();
 	void clearCloudDraft();
 	void clearEditDraft();
@@ -560,14 +560,14 @@ private:
 		int expectedItemsCount = 0; // optimization for block->items.reserve() call
 		HistoryBlock *block = nullptr;
 	};
-	std_::unique_ptr<BuildingBlock> _buildingFrontBlock;
+	std::unique_ptr<BuildingBlock> _buildingFrontBlock;
 
 	// Creates if necessary a new block for adding item.
 	// Depending on isBuildingFrontBlock() gets front or back block.
 	HistoryBlock *prepareBlockForAddingItem();
 
-	std_::unique_ptr<Data::Draft> _localDraft, _cloudDraft;
+	std::unique_ptr<Data::Draft> _localDraft, _cloudDraft;
-	std_::unique_ptr<Data::Draft> _editDraft;
+	std::unique_ptr<Data::Draft> _editDraft;
 
 	using TypingUsers = QMap<UserData*, TimeMs>;
 	TypingUsers _typing;

Telegram/SourceFiles/history/history_drag_area.h

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

Telegram/SourceFiles/history/history_item.cpp

@@ -99,7 +99,7 @@ QString ReplyMarkupClickHandler::buttonText() const {
 ReplyKeyboard::ReplyKeyboard(const HistoryItem *item, StylePtr &&s)
 	: _item(item)
 	, _a_selected(animation(this, &ReplyKeyboard::step_selected))
-	, _st(std_::move(s)) {
+	, _st(std::move(s)) {
 	if (auto markup = item->Get<HistoryMessageReplyMarkup>()) {
 		_rows.reserve(markup->rows.size());
 		for (int i = 0, l = markup->rows.size(); i != l; ++i) {
@@ -197,7 +197,7 @@ bool ReplyKeyboard::isEnoughSpace(int width, const style::BotKeyboardButton &st)
 }
 
 void ReplyKeyboard::setStyle(StylePtr &&st) {
-	_st = std_::move(st);
+	_st = std::move(st);
 }
 
 int ReplyKeyboard::naturalWidth() const {
@@ -292,7 +292,7 @@ void ReplyKeyboard::clickHandlerPressedChanged(const ClickHandlerPtr &p, bool pr
 		if (pressed) {
 			if (!button.ripple) {
 				auto mask = Ui::RippleAnimation::roundRectMask(button.rect.size(), _st->buttonRadius());
-				button.ripple = MakeShared<Ui::RippleAnimation>(_st->_st->ripple, std_::move(mask), [this] { _st->repaint(_item); });
+				button.ripple = MakeShared<Ui::RippleAnimation>(_st->_st->ripple, std::move(mask), [this] { _st->repaint(_item); });
 			}
 			button.ripple->add(_savedCoords - button.rect.topLeft());
 		} else {

Telegram/SourceFiles/history/history_item.h

@@ -146,12 +146,12 @@ struct HistoryMessageReply : public RuntimeComponent<HistoryMessageReply> {
 	HistoryMessageReply &operator=(HistoryMessageReply &&other) {
 		replyToMsgId = other.replyToMsgId;
 		std::swap(replyToMsg, other.replyToMsg);
-		replyToLnk = std_::move(other.replyToLnk);
+		replyToLnk = std::move(other.replyToLnk);
-		replyToName = std_::move(other.replyToName);
+		replyToName = std::move(other.replyToName);
-		replyToText = std_::move(other.replyToText);
+		replyToText = std::move(other.replyToText);
 		replyToVersion = other.replyToVersion;
 		_maxReplyWidth = other._maxReplyWidth;
-		_replyToVia = std_::move(other._replyToVia);
+		_replyToVia = std::move(other._replyToVia);
 		return *this;
 	}
 	~HistoryMessageReply() {
@@ -191,7 +191,7 @@ struct HistoryMessageReply : public RuntimeComponent<HistoryMessageReply> {
 	mutable Text replyToName, replyToText;
 	mutable int replyToVersion = 0;
 	mutable int _maxReplyWidth = 0;
-	std_::unique_ptr<HistoryMessageVia> _replyToVia;
+	std::unique_ptr<HistoryMessageVia> _replyToVia;
 	int toWidth = 0;
 };
 Q_DECLARE_OPERATORS_FOR_FLAGS(HistoryMessageReply::PaintFlags);
@@ -227,7 +227,7 @@ struct HistoryMessageReplyMarkup : public RuntimeComponent<HistoryMessageReplyMa
 	ButtonRows rows;
 	MTPDreplyKeyboardMarkup::Flags flags = 0;
 
-	std_::unique_ptr<ReplyKeyboard> inlineKeyboard;
+	std::unique_ptr<ReplyKeyboard> inlineKeyboard;
 
 	// If >= 0 it holds the y coord of the inlineKeyboard before the last edition.
 	int oldTop = -1;
@@ -313,7 +313,7 @@ public:
 		friend class ReplyKeyboard;
 
 	};
-	typedef std_::unique_ptr<Style> StylePtr;
+	typedef std::unique_ptr<Style> StylePtr;
 
 	ReplyKeyboard(const HistoryItem *item, StylePtr &&s);
 	ReplyKeyboard(const ReplyKeyboard &other) = delete;

Telegram/SourceFiles/history/history_location_manager.cpp

@@ -89,7 +89,7 @@ void LocationManager::init() {
 	auto data = QImage(cIntRetinaFactor(), cIntRetinaFactor(), QImage::Format_ARGB32_Premultiplied);
 	data.fill(st::imageBgTransparent->c);
 	data.setDevicePixelRatio(cRetinaFactor());
-	notLoadedPlaceholder = new ImagePtr(App::pixmapFromImageInPlace(std_::move(data)), "GIF");
+	notLoadedPlaceholder = new ImagePtr(App::pixmapFromImageInPlace(std::move(data)), "GIF");
 }
 
 void LocationManager::reinit() {

Telegram/SourceFiles/history/history_media_types.cpp

@@ -124,7 +124,7 @@ TextWithEntities captionedSelectedText(const QString &attachType, const Text &ca
 	result.text.append(qstr("[ ")).append(attachType).append(qstr(" ]"));
 	if (!caption.isEmpty()) {
 		result.text.append(qstr("\n"));
-		appendTextWithEntities(result, std_::move(original));
+		appendTextWithEntities(result, std::move(original));
 	}
 	return result;
 }
@@ -171,9 +171,9 @@ void HistoryFileMedia::clickHandlerPressedChanged(const ClickHandlerPtr &p, bool
 }
 
 void HistoryFileMedia::setLinks(ClickHandlerPtr &&openl, ClickHandlerPtr &&savel, ClickHandlerPtr &&cancell) {
-	_openl = std_::move(openl);
+	_openl = std::move(openl);
-	_savel = std_::move(savel);
+	_savel = std::move(savel);
-	_cancell = std_::move(cancell);
+	_cancell = std::move(cancell);
 }
 
 void HistoryFileMedia::setStatusSize(int32 newSize, int32 fullSize, int32 duration, qint64 realDuration) const {
@@ -204,7 +204,7 @@ void HistoryFileMedia::step_radial(TimeMs ms, bool timer) {
 
 void HistoryFileMedia::ensureAnimation() const {
 	if (!_animation) {
-		_animation = std_::make_unique<AnimationData>(animation(const_cast<HistoryFileMedia*>(this), &HistoryFileMedia::step_radial));
+		_animation = std::make_unique<AnimationData>(animation(const_cast<HistoryFileMedia*>(this), &HistoryFileMedia::step_radial));
 	}
 }
 
@@ -910,7 +910,7 @@ HistoryDocumentVoicePlayback::HistoryDocumentVoicePlayback(const HistoryDocument
 
 void HistoryDocumentVoice::ensurePlayback(const HistoryDocument *that) const {
 	if (!_playback) {
-		_playback = std_::make_unique<HistoryDocumentVoicePlayback>(that);
+		_playback = std::make_unique<HistoryDocumentVoicePlayback>(that);
 	}
 }
 
@@ -2573,16 +2573,16 @@ void HistoryWebPage::initDimensions() {
 	if (!_asArticle && !_attach) {
 		if (_data->document) {
 			if (_data->document->sticker()) {
-				_attach = std_::make_unique<HistorySticker>(_parent, _data->document);
+				_attach = std::make_unique<HistorySticker>(_parent, _data->document);
 			} else if (_data->document->isAnimation()) {
-				_attach = std_::make_unique<HistoryGif>(_parent, _data->document, QString());
+				_attach = std::make_unique<HistoryGif>(_parent, _data->document, QString());
 			} else if (_data->document->isVideo()) {
-				_attach = std_::make_unique<HistoryVideo>(_parent, _data->document, QString());
+				_attach = std::make_unique<HistoryVideo>(_parent, _data->document, QString());
 			} else {
-				_attach = std_::make_unique<HistoryDocument>(_parent, _data->document, QString());
+				_attach = std::make_unique<HistoryDocument>(_parent, _data->document, QString());
 			}
 		} else if (_data->photo) {
-			_attach = std_::make_unique<HistoryPhoto>(_parent, _data->photo, QString());
+			_attach = std::make_unique<HistoryPhoto>(_parent, _data->photo, QString());
 		}
 	}
 
@@ -2992,7 +2992,7 @@ TextWithEntities HistoryWebPage::selectedText(TextSelection selection) const {
 	}
 
 	titleResult.text += '\n';
-	appendTextWithEntities(titleResult, std_::move(descriptionResult));
+	appendTextWithEntities(titleResult, std::move(descriptionResult));
 	return titleResult;
 }
 
@@ -3046,16 +3046,16 @@ void HistoryGame::initDimensions() {
 	if (!_attach) {
 		if (_data->document) {
 			if (_data->document->sticker()) {
-				_attach = std_::make_unique<HistorySticker>(_parent, _data->document);
+				_attach = std::make_unique<HistorySticker>(_parent, _data->document);
 			} else if (_data->document->isAnimation()) {
-				_attach = std_::make_unique<HistoryGif>(_parent, _data->document, QString());
+				_attach = std::make_unique<HistoryGif>(_parent, _data->document, QString());
 			} else if (_data->document->isVideo()) {
-				_attach = std_::make_unique<HistoryVideo>(_parent, _data->document, QString());
+				_attach = std::make_unique<HistoryVideo>(_parent, _data->document, QString());
 			} else {
-				_attach = std_::make_unique<HistoryDocument>(_parent, _data->document, QString());
+				_attach = std::make_unique<HistoryDocument>(_parent, _data->document, QString());
 			}
 		} else if (_data->photo) {
-			_attach = std_::make_unique<HistoryPhoto>(_parent, _data->photo, QString());
+			_attach = std::make_unique<HistoryPhoto>(_parent, _data->photo, QString());
 		}
 	}
 
@@ -3363,7 +3363,7 @@ TextWithEntities HistoryGame::selectedText(TextSelection selection) const {
 	}
 
 	titleResult.text += '\n';
-	appendTextWithEntities(titleResult, std_::move(descriptionResult));
+	appendTextWithEntities(titleResult, std::move(descriptionResult));
 	return titleResult;
 }
 
@@ -3636,7 +3636,7 @@ TextWithEntities HistoryLocation::selectedText(TextSelection selection) const {
 		TextWithEntities result = { qsl("[ ") + lang(lng_maps_point) + qsl(" ]\n"), EntitiesInText() };
 		auto info = selectedText(AllTextSelection);
 		if (!info.text.isEmpty()) {
-			appendTextWithEntities(result, std_::move(info));
+			appendTextWithEntities(result, std::move(info));
 			result.text.append('\n');
 		}
 		result.text += _link->dragText();
@@ -3651,7 +3651,7 @@ TextWithEntities HistoryLocation::selectedText(TextSelection selection) const {
 		return titleResult;
 	}
 	titleResult.text += '\n';
-	appendTextWithEntities(titleResult, std_::move(descriptionResult));
+	appendTextWithEntities(titleResult, std::move(descriptionResult));
 	return titleResult;
 }
 

Telegram/SourceFiles/history/history_media_types.h

@@ -57,7 +57,7 @@ protected:
 		} else {
 			save.reset(new DocumentSaveClickHandler(document));
 		}
-		setLinks(std_::move(open), std_::move(save), MakeShared<DocumentCancelClickHandler>(document));
+		setLinks(std::move(open), std::move(save), MakeShared<DocumentCancelClickHandler>(document));
 	}
 
 	// >= 0 will contain download / upload string, _statusSize = loaded bytes
@@ -99,12 +99,12 @@ protected:
 
 	struct AnimationData {
 		AnimationData(AnimationCallbacks &&radialCallbacks)
-			: radial(std_::move(radialCallbacks)) {
+			: radial(std::move(radialCallbacks)) {
 		}
 		Animation a_thumbOver;
 		Ui::RadialAnimation radial;
 	};
-	mutable std_::unique_ptr<AnimationData> _animation;
+	mutable std::unique_ptr<AnimationData> _animation;
 
 };
 
@@ -319,7 +319,7 @@ public:
 	void ensurePlayback(const HistoryDocument *interfaces) const;
 	void checkPlaybackFinished() const;
 
-	mutable std_::unique_ptr<HistoryDocumentVoicePlayback> _playback;
+	mutable std::unique_ptr<HistoryDocumentVoicePlayback> _playback;
 	QSharedPointer<VoiceSeekClickHandler> _seekl;
 	mutable int _lastDurationMs = 0;
 
@@ -757,7 +757,7 @@ private:
 
 	WebPageData *_data;
 	ClickHandlerPtr _openl;
-	std_::unique_ptr<HistoryMedia> _attach;
+	std::unique_ptr<HistoryMedia> _attach;
 
 	bool _asArticle = false;
 	int32 _titleLines, _descriptionLines;
@@ -862,7 +862,7 @@ private:
 
 	GameData *_data;
 	ClickHandlerPtr _openl;
-	std_::unique_ptr<HistoryMedia> _attach;
+	std::unique_ptr<HistoryMedia> _attach;
 
 	int32 _titleLines, _descriptionLines;
 

Telegram/SourceFiles/history/history_message.cpp

@@ -826,7 +826,7 @@ void HistoryMessage::initDimensions() {
 	}
 	if (auto markup = inlineReplyMarkup()) {
 		if (!markup->inlineKeyboard) {
-			markup->inlineKeyboard.reset(new ReplyKeyboard(this, std_::make_unique<KeyboardStyle>(st::msgBotKbButton)));
+			markup->inlineKeyboard.reset(new ReplyKeyboard(this, std::make_unique<KeyboardStyle>(st::msgBotKbButton)));
 		}
 
 		// if we have a text bubble we can resize it to fit the keyboard
@@ -989,7 +989,7 @@ TextWithEntities HistoryMessage::selectedText(TextSelection selection) const {
 	} else {
 		result.text = textResult.text + qstr("\n\n");
 		result.entities = textResult.entities;
-		appendTextWithEntities(result, std_::move(mediaResult));
+		appendTextWithEntities(result, std::move(mediaResult));
 	}
 	if (auto fwd = Get<HistoryMessageForwarded>()) {
 		if (selection == FullSelection) {
@@ -998,9 +998,9 @@ TextWithEntities HistoryMessage::selectedText(TextSelection selection) const {
 			wrapped.text.reserve(fwdinfo.text.size() + 4 + result.text.size());
 			wrapped.entities.reserve(fwdinfo.entities.size() + result.entities.size());
 			wrapped.text.append('[');
-			appendTextWithEntities(wrapped, std_::move(fwdinfo));
+			appendTextWithEntities(wrapped, std::move(fwdinfo));
 			wrapped.text.append(qsl("]\n"));
-			appendTextWithEntities(wrapped, std_::move(result));
+			appendTextWithEntities(wrapped, std::move(result));
 			result = wrapped;
 		}
 	}
@@ -1009,7 +1009,7 @@ TextWithEntities HistoryMessage::selectedText(TextSelection selection) const {
 			TextWithEntities wrapped;
 			wrapped.text.reserve(lang(lng_in_reply_to).size() + reply->replyToMsg->author()->name.size() + 4 + result.text.size());
 			wrapped.text.append('[').append(lang(lng_in_reply_to)).append(' ').append(reply->replyToMsg->author()->name).append(qsl("]\n"));
-			appendTextWithEntities(wrapped, std_::move(result));
+			appendTextWithEntities(wrapped, std::move(result));
 			result = wrapped;
 		}
 	}

Telegram/SourceFiles/history/history_service_layout.cpp

@@ -104,7 +104,7 @@ QPixmap circleCorner(int corner) {
 		auto part = QRect(xoffset, yoffset, size, size);
 		auto result = style::colorizeImage(serviceMessageStyle->circle[maskType], st::msgServiceBg, part);
 		result.setDevicePixelRatio(cRetinaFactor());
-		serviceMessageStyle->corners[corner] = App::pixmapFromImageInPlace(std_::move(result));
+		serviceMessageStyle->corners[corner] = App::pixmapFromImageInPlace(std::move(result));
 	}
 	return serviceMessageStyle->corners[corner];
 }

Telegram/SourceFiles/historywidget.cpp

@@ -1038,7 +1038,7 @@ void HistoryInner::onDragExec() {
 		updateDragSelection(0, 0, false);
 		_widget->noSelectingScroll();
 
-		auto drag = std_::make_unique<QDrag>(App::wnd());
+		auto drag = std::make_unique<QDrag>(App::wnd());
 		if (!urls.isEmpty()) mimeData->setUrls(urls);
 		if (uponSelected && !_selected.isEmpty() && _selected.cbegin().value() == FullSelection && !Adaptive::OneColumn()) {
 			mimeData->setData(qsl("application/x-td-forward-selected"), "1");
@@ -1067,8 +1067,8 @@ void HistoryInner::onDragExec() {
 			}
 		}
 		if (!forwardMimeType.isEmpty()) {
-			auto drag = std_::make_unique<QDrag>(App::wnd());
+			auto drag = std::make_unique<QDrag>(App::wnd());
-			auto mimeData = std_::make_unique<QMimeData>();
+			auto mimeData = std::make_unique<QMimeData>();
 
 			mimeData->setData(forwardMimeType, "1");
 			if (auto document = (pressedMedia ? pressedMedia->getDocument() : nullptr)) {
@@ -1597,7 +1597,7 @@ TextWithEntities HistoryInner::getSelectedText() const {
 		int y = itemTop(item);
 		if (y >= 0) {
 			part.text.append(item->author()->name).append(time);
-			appendTextWithEntities(part, std_::move(unwrapped));
+			appendTextWithEntities(part, std::move(unwrapped));
 			texts.insert(y, part);
 			fullSize += size;
 		}
@@ -1607,7 +1607,7 @@ TextWithEntities HistoryInner::getSelectedText() const {
 	auto sep = qsl("\n\n");
 	result.text.reserve(fullSize + (texts.size() - 1) * sep.size());
 	for (auto i = texts.begin(), e = texts.end(); i != e; ++i) {
-		appendTextWithEntities(result, std_::move(i.value()));
+		appendTextWithEntities(result, std::move(i.value()));
 		if (i + 1 != e) {
 			result.text.append(sep);
 		}
@@ -2672,7 +2672,7 @@ bool BotKeyboard::updateMarkup(HistoryItem *to, bool force) {
 	_impl = nullptr;
 	if (auto markup = to->Get<HistoryMessageReplyMarkup>()) {
 		if (!markup->rows.isEmpty()) {
-			_impl.reset(new ReplyKeyboard(to, std_::make_unique<Style>(this, *_st)));
+			_impl.reset(new ReplyKeyboard(to, std::make_unique<Style>(this, *_st)));
 		}
 	}
 
@@ -2717,7 +2717,7 @@ void BotKeyboard::updateStyle(int newWidth) {
 	int implWidth = newWidth - st::botKbButton.margin - st::botKbScroll.width;
 	_st = _impl->isEnoughSpace(implWidth, st::botKbButton) ? &st::botKbButton : &st::botKbTinyButton;
 
-	_impl->setStyle(std_::make_unique<Style>(this, *_st));
+	_impl->setStyle(std::make_unique<Style>(this, *_st));
 }
 
 void BotKeyboard::clearSelection() {
@@ -3211,7 +3211,7 @@ HistoryWidget::HistoryWidget(QWidget *parent) : TWidget(parent)
 	connect(_fieldAutocomplete, SIGNAL(stickerChosen(DocumentData*,FieldAutocomplete::ChooseMethod)), this, SLOT(onStickerSend(DocumentData*)));
 	connect(_fieldAutocomplete, SIGNAL(moderateKeyActivate(int,bool*)), this, SLOT(onModerateKeyActivate(int,bool*)));
 	_field->installEventFilter(_fieldAutocomplete);
-	_field->setTagMimeProcessor(std_::make_unique<FieldTagMimeProcessor>());
+	_field->setTagMimeProcessor(std::make_unique<FieldTagMimeProcessor>());
 	updateFieldSubmitSettings();
 
 	_field->hide();
@@ -3415,10 +3415,10 @@ void HistoryWidget::saveFieldToHistoryLocalDraft() {
 	if (!_history) return;
 
 	if (_editMsgId) {
-		_history->setEditDraft(std_::make_unique<Data::Draft>(_field, _editMsgId, _previewCancelled, _saveEditMsgRequestId));
+		_history->setEditDraft(std::make_unique<Data::Draft>(_field, _editMsgId, _previewCancelled, _saveEditMsgRequestId));
 	} else {
 		if (_replyToId || !_field->isEmpty()) {
-			_history->setLocalDraft(std_::make_unique<Data::Draft>(_field, _replyToId, _previewCancelled));
+			_history->setLocalDraft(std::make_unique<Data::Draft>(_field, _replyToId, _previewCancelled));
 		} else {
 			_history->clearLocalDraft();
 		}
@@ -3658,7 +3658,7 @@ bool HistoryWidget::notify_switchInlineBotButtonReceived(const QString &query, U
 			TextWithTags textWithTags = { '@' + samePeerBot->username + ' ' + query, TextWithTags::Tags() };
 			MessageCursor cursor = { textWithTags.text.size(), textWithTags.text.size(), QFIXED_MAX };
 			auto replyTo = _history->peer->isUser() ? 0 : samePeerReplyTo;
-			_history->setLocalDraft(std_::make_unique<Data::Draft>(textWithTags, replyTo, cursor, false));
+			_history->setLocalDraft(std::make_unique<Data::Draft>(textWithTags, replyTo, cursor, false));
 			applyDraft();
 			return true;
 		}
@@ -3671,7 +3671,7 @@ bool HistoryWidget::notify_switchInlineBotButtonReceived(const QString &query, U
 		History *h = App::history(toPeerId);
 		TextWithTags textWithTags = { '@' + bot->username + ' ' + query, TextWithTags::Tags() };
 		MessageCursor cursor = { textWithTags.text.size(), textWithTags.text.size(), QFIXED_MAX };
-		h->setLocalDraft(std_::make_unique<Data::Draft>(textWithTags, 0, cursor, false));
+		h->setLocalDraft(std::make_unique<Data::Draft>(textWithTags, 0, cursor, false));
 		if (h == _history) {
 			applyDraft();
 		} else {
@@ -6530,7 +6530,7 @@ bool HistoryWidget::showSendFilesBox(object_ptr<SendFilesBox> box, const QString
 	App::wnd()->activateWindow();
 
 	auto withComment = (addedComment != nullptr);
-	box->setConfirmedCallback(base::lambda_guarded(this, [this, withComment, sendCallback = std_::move(callback)](const QStringList &files, bool compressed, const QString &caption, bool ctrlShiftEnter) {
+	box->setConfirmedCallback(base::lambda_guarded(this, [this, withComment, sendCallback = std::move(callback)](const QStringList &files, bool compressed, const QString &caption, bool ctrlShiftEnter) {
 		if (!canWriteMessage()) return;
 
 		auto replyTo = replyToId();
@@ -6552,7 +6552,7 @@ bool HistoryWidget::showSendFilesBox(object_ptr<SendFilesBox> box, const QString
 		}));
 	}
 
-	Ui::show(std_::move(box));
+	Ui::show(std::move(box));
 	return true;
 }
 
@@ -6598,7 +6598,7 @@ bool HistoryWidget::confirmSendingFiles(const SendingFilesLists &lists, Compress
 			auto type = compressed ? SendMediaType::Photo : SendMediaType::File;
 			uploadFilesAfterConfirmation(files, image, QByteArray(), type, caption);
 		};
-		return showSendFilesBox(std_::move(box), insertTextOnCancel, addedComment, std_::move(sendCallback));
+		return showSendFilesBox(std::move(box), insertTextOnCancel, addedComment, std::move(sendCallback));
 	});
 }
 
@@ -6612,7 +6612,7 @@ bool HistoryWidget::confirmSendingFiles(const QImage &image, const QByteArray &c
 		uploadFilesAfterConfirmation(files, image, content, type, caption);
 	};
 	auto box = Box<SendFilesBox>(QString(), image, imageCompressConfirm(image, compressed), animated);
-	return showSendFilesBox(std_::move(box), insertTextOnCancel, nullptr, std_::move(sendCallback));
+	return showSendFilesBox(std::move(box), insertTextOnCancel, nullptr, std::move(sendCallback));
 }
 
 bool HistoryWidget::confirmSendingFiles(const QMimeData *data, CompressConfirm compressed, const QString &insertTextOnCancel) {
@@ -6647,7 +6647,7 @@ bool HistoryWidget::confirmShareContact(const QString &phone, const QString &fna
 		shareContact(_peer->id, phone, fname, lname, replyTo);
 	};
 	auto insertTextOnCancel = QString();
-	return showSendFilesBox(std_::move(box), insertTextOnCancel, addedComment, std_::move(sendCallback));
+	return showSendFilesBox(std::move(box), insertTextOnCancel, addedComment, std::move(sendCallback));
 }
 
 HistoryWidget::SendingFilesLists HistoryWidget::getSendingFilesLists(const QList<QUrl> &files) {
@@ -7726,7 +7726,7 @@ bool HistoryWidget::pinnedMsgVisibilityUpdated() {
 	}
 	if (pinnedMsgId) {
 		if (!_pinnedBar) {
-			_pinnedBar = std_::make_unique<PinnedBar>(pinnedMsgId, this);
+			_pinnedBar = std::make_unique<PinnedBar>(pinnedMsgId, this);
 			if (_a_show.animating()) {
 				_pinnedBar->cancel->hide();
 				_pinnedBar->shadow->hide();
@@ -7926,7 +7926,7 @@ void HistoryWidget::onReplyToMessage() {
 		if (auto localDraft = _history->localDraft()) {
 			localDraft->msgId = to->id;
 		} else {
-			_history->setLocalDraft(std_::make_unique<Data::Draft>(TextWithTags(), to->id, MessageCursor(), false));
+			_history->setLocalDraft(std::make_unique<Data::Draft>(TextWithTags(), to->id, MessageCursor(), false));
 		}
 	} else {
 		_replyEditMsg = to;
@@ -7962,7 +7962,7 @@ void HistoryWidget::onEditMessage() {
 		}
 		if (!_editMsgId) {
 			if (_replyToId || !_field->isEmpty()) {
-				_history->setLocalDraft(std_::make_unique<Data::Draft>(_field, _replyToId, _previewCancelled));
+				_history->setLocalDraft(std::make_unique<Data::Draft>(_field, _replyToId, _previewCancelled));
 			} else {
 				_history->clearLocalDraft();
 			}
@@ -7973,7 +7973,7 @@ void HistoryWidget::onEditMessage() {
 		auto editTags = textTagsFromEntities(original.entities);
 		TextWithTags editData = { editText, editTags };
 		MessageCursor cursor = { editText.size(), editText.size(), QFIXED_MAX };
-		_history->setEditDraft(std_::make_unique<Data::Draft>(editData, to->id, cursor, false));
+		_history->setEditDraft(std::make_unique<Data::Draft>(editData, to->id, cursor, false));
 		applyDraft(false);
 
 		_previewData = nullptr;

Telegram/SourceFiles/historywidget.h

@@ -203,7 +203,7 @@ private:
 		HistoryInner *_parent;
 
 	};
-	std_::unique_ptr<BotAbout> _botAbout;
+	std::unique_ptr<BotAbout> _botAbout;
 
 	HistoryWidget *_widget = nullptr;
 	Ui::ScrollArea *_scroll = nullptr;
@@ -430,7 +430,7 @@ private:
 	bool _forceReply = false;
 
 	QPoint _lastMousePos;
-	std_::unique_ptr<ReplyKeyboard> _impl;
+	std::unique_ptr<ReplyKeyboard> _impl;
 
 	class Style : public ReplyKeyboard::Style {
 	public:
@@ -920,7 +920,7 @@ private:
 		object_ptr<Ui::IconButton> cancel;
 		object_ptr<Ui::PlainShadow> shadow;
 	};
-	std_::unique_ptr<PinnedBar> _pinnedBar;
+	std::unique_ptr<PinnedBar> _pinnedBar;
 	void updatePinnedBar(bool force = false);
 	bool pinnedMsgVisibilityUpdated();
 	void destroyPinnedBar();

Telegram/SourceFiles/inline_bots/inline_bot_layout_internal.cpp

@@ -304,7 +304,7 @@ void Gif::prepareThumb(int32 width, int32 height, const QSize &frame) const {
 
 void Gif::ensureAnimation() const {
 	if (!_animation) {
-		_animation = std_::make_unique<AnimationData>(animation(const_cast<Gif*>(this), &Gif::step_radial));
+		_animation = std::make_unique<AnimationData>(animation(const_cast<Gif*>(this), &Gif::step_radial));
 	}
 }
 
@@ -1198,7 +1198,7 @@ void Game::paint(Painter &p, const QRect &clip, const PaintContext *context) con
 		bool animating = (_gif && _gif->started());
 		if (displayLoading) {
 			if (!_radial) {
-				_radial = std_::make_unique<Ui::RadialAnimation>(animation(const_cast<Game*>(this), &Game::step_radial));
+				_radial = std::make_unique<Ui::RadialAnimation>(animation(const_cast<Game*>(this), &Game::step_radial));
 			}
 			if (!_radial->animating()) {
 				_radial->start(document->progress());

Telegram/SourceFiles/inline_bots/inline_bot_layout_internal.h

@@ -104,13 +104,13 @@ private:
 	struct AnimationData {
 		AnimationData(AnimationCallbacks &&callbacks)
 			: over(false)
-			, radial(std_::move(callbacks)) {
+			, radial(std::move(callbacks)) {
 		}
 		bool over;
 		Animation _a_over;
 		Ui::RadialAnimation radial;
 	};
-	mutable std_::unique_ptr<AnimationData> _animation;
+	mutable std::unique_ptr<AnimationData> _animation;
 	mutable Animation _a_deleteOver;
 
 };
@@ -266,12 +266,12 @@ private:
 	}
 
 	struct AnimationData {
-		AnimationData(AnimationCallbacks &&radialCallbacks) : radial(std_::move(radialCallbacks)) {
+		AnimationData(AnimationCallbacks &&radialCallbacks) : radial(std::move(radialCallbacks)) {
 		}
 		Animation a_thumbOver;
 		Ui::RadialAnimation radial;
 	};
-	mutable std_::unique_ptr<AnimationData> _animation;
+	mutable std::unique_ptr<AnimationData> _animation;
 
 	Text _title, _description;
 	ClickHandlerPtr _open, _cancel;
@@ -354,7 +354,7 @@ private:
 
 	Media::Clip::ReaderPointer _gif;
 	mutable QPixmap _thumb;
-	mutable std_::unique_ptr<Ui::RadialAnimation> _radial;
+	mutable std::unique_ptr<Ui::RadialAnimation> _radial;
 	Text _title, _description;
 
 	QSize _frameSize;

Telegram/SourceFiles/inline_bots/inline_bot_layout_item.cpp

@@ -100,27 +100,27 @@ void ItemBase::update() {
 	}
 }
 
-std_::unique_ptr<ItemBase> ItemBase::createLayout(Result *result, bool forceThumb) {
+std::unique_ptr<ItemBase> ItemBase::createLayout(Result *result, bool forceThumb) {
 	using Type = Result::Type;
 
 	switch (result->_type) {
-	case Type::Photo: return std_::make_unique<internal::Photo>(result); break;
+	case Type::Photo: return std::make_unique<internal::Photo>(result); break;
 	case Type::Audio:
-	case Type::File: return std_::make_unique<internal::File>(result); break;
+	case Type::File: return std::make_unique<internal::File>(result); break;
-	case Type::Video: return std_::make_unique<internal::Video>(result); break;
+	case Type::Video: return std::make_unique<internal::Video>(result); break;
-	case Type::Sticker: return std_::make_unique<internal::Sticker>(result); break;
+	case Type::Sticker: return std::make_unique<internal::Sticker>(result); break;
-	case Type::Gif: return std_::make_unique<internal::Gif>(result); break;
+	case Type::Gif: return std::make_unique<internal::Gif>(result); break;
 	case Type::Article:
 	case Type::Geo:
-	case Type::Venue: return std_::make_unique<internal::Article>(result, forceThumb); break;
+	case Type::Venue: return std::make_unique<internal::Article>(result, forceThumb); break;
-	case Type::Game: return std_::make_unique<internal::Game>(result); break;
+	case Type::Game: return std::make_unique<internal::Game>(result); break;
-	case Type::Contact: return std_::make_unique<internal::Contact>(result); break;
+	case Type::Contact: return std::make_unique<internal::Contact>(result); break;
 	}
-	return std_::unique_ptr<ItemBase>();
+	return std::unique_ptr<ItemBase>();
 }
 
-std_::unique_ptr<ItemBase> ItemBase::createLayoutGif(DocumentData *document) {
+std::unique_ptr<ItemBase> ItemBase::createLayoutGif(DocumentData *document) {
-	return std_::make_unique<internal::Gif>(document, true);
+	return std::make_unique<internal::Gif>(document, true);
 }
 
 DocumentData *ItemBase::getResultDocument() const {
@@ -150,7 +150,7 @@ QPixmap ItemBase::getResultContactAvatar(int width, int height) const {
 		if (result.height() != height * cIntRetinaFactor()) {
 			result = result.scaled(QSize(width, height) * cIntRetinaFactor(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 		}
-		return std_::move(result);
+		return std::move(result);
 	}
 	return QPixmap();
 }

Telegram/SourceFiles/inline_bots/inline_bot_layout_item.h

@@ -91,8 +91,8 @@ public:
 		update();
 	}
 
-	static std_::unique_ptr<ItemBase> createLayout(Result *result, bool forceThumb);
+	static std::unique_ptr<ItemBase> createLayout(Result *result, bool forceThumb);
-	static std_::unique_ptr<ItemBase> createLayoutGif(DocumentData *document);
+	static std::unique_ptr<ItemBase> createLayoutGif(DocumentData *document);
 
 protected:
 	DocumentData *getResultDocument() const;

Telegram/SourceFiles/inline_bots/inline_bot_result.cpp

@@ -32,10 +32,10 @@ namespace InlineBots {
 Result::Result(const Creator &creator) : _queryId(creator.queryId), _type(creator.type) {
 }
 
-std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult &mtpData) {
+std::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult &mtpData) {
 	using StringToTypeMap = QMap<QString, Result::Type>;
 	static StaticNeverFreedPointer<StringToTypeMap> stringToTypeMap{ ([]() -> StringToTypeMap* {
-		auto result = std_::make_unique<StringToTypeMap>();
+		auto result = std::make_unique<StringToTypeMap>();
 		result->insert(qsl("photo"), Result::Type::Photo);
 		result->insert(qsl("video"), Result::Type::Video);
 		result->insert(qsl("audio"), Result::Type::Audio);
@@ -61,10 +61,10 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 	};
 	Type type = getInlineResultType(mtpData);
 	if (type == Type::Unknown) {
-		return std_::unique_ptr<Result>();
+		return std::unique_ptr<Result>();
 	}
 
-	auto result = std_::make_unique<Result>(Creator{ queryId, type });
+	auto result = std::make_unique<Result>(Creator{ queryId, type });
 	const MTPBotInlineMessage *message = nullptr;
 	switch (mtpData.type()) {
 	case mtpc_botInlineResult: {
@@ -101,18 +101,18 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 	bool badAttachment = (result->_photo && !result->_photo->access) || (result->_document && !result->_document->isValid());
 
 	if (!message) {
-		return std_::unique_ptr<Result>();
+		return std::unique_ptr<Result>();
 	}
 
 	// Ensure required media fields for layouts.
 	if (result->_type == Type::Photo) {
 		if (!result->_photo && result->_content_url.isEmpty()) {
-			return std_::unique_ptr<Result>();
+			return std::unique_ptr<Result>();
 		}
 		result->createPhoto();
 	} else if (result->_type == Type::File || result->_type == Type::Gif || result->_type == Type::Sticker) {
 		if (!result->_document && result->_content_url.isEmpty()) {
-			return std_::unique_ptr<Result>();
+			return std::unique_ptr<Result>();
 		}
 		result->createDocument();
 	}
@@ -131,7 +131,7 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 			result->sendData.reset(new internal::SendFile(result->_document, qs(r.vcaption)));
 		}
 		if (r.has_reply_markup()) {
-			result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
+			result->_mtpKeyboard = std::make_unique<MTPReplyMarkup>(r.vreply_markup);
 		}
 	} break;
 
@@ -145,7 +145,7 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 			result->createDocument();
 		}
 		if (r.has_reply_markup()) {
-			result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
+			result->_mtpKeyboard = std::make_unique<MTPReplyMarkup>(r.vreply_markup);
 		}
 	} break;
 
@@ -157,7 +157,7 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 			badAttachment = true;
 		}
 		if (r.has_reply_markup()) {
-			result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
+			result->_mtpKeyboard = std::make_unique<MTPReplyMarkup>(r.vreply_markup);
 		}
 	} break;
 
@@ -169,7 +169,7 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 			badAttachment = true;
 		}
 		if (r.has_reply_markup()) {
-			result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
+			result->_mtpKeyboard = std::make_unique<MTPReplyMarkup>(r.vreply_markup);
 		}
 	} break;
 
@@ -177,7 +177,7 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 		auto &r = message->c_botInlineMessageMediaContact();
 		result->sendData.reset(new internal::SendContact(qs(r.vfirst_name), qs(r.vlast_name), qs(r.vphone_number)));
 		if (r.has_reply_markup()) {
-			result->_mtpKeyboard = std_::make_unique<MTPReplyMarkup>(r.vreply_markup);
+			result->_mtpKeyboard = std::make_unique<MTPReplyMarkup>(r.vreply_markup);
 		}
 	} break;
 
@@ -187,7 +187,7 @@ std_::unique_ptr<Result> Result::create(uint64 queryId, const MTPBotInlineResult
 	}
 
 	if (badAttachment || !result->sendData || !result->sendData->isValid()) {
-		return std_::unique_ptr<Result>();
+		return std::unique_ptr<Result>();
 	}
 
 	if (result->_thumb->isNull() && !result->_thumb_url.isEmpty()) {

Telegram/SourceFiles/inline_bots/inline_bot_result.h

@@ -43,10 +43,10 @@ private:
 
 public:
 
-	// Constructor is public only for std_::make_unique<>() to work.
+	// Constructor is public only for std::make_unique<>() to work.
 	// You should use create() static method instead.
 	explicit Result(const Creator &creator);
-	static std_::unique_ptr<Result> create(uint64 queryId, const MTPBotInlineResult &mtpData);
+	static std::unique_ptr<Result> create(uint64 queryId, const MTPBotInlineResult &mtpData);
 	Result(const Result &other) = delete;
 	Result &operator=(const Result &other) = delete;
 
@@ -116,11 +116,11 @@ private:
 	PhotoData *_photo = nullptr;
 	GameData *_game = nullptr;
 
-	std_::unique_ptr<MTPReplyMarkup> _mtpKeyboard;
+	std::unique_ptr<MTPReplyMarkup> _mtpKeyboard;
 
 	ImagePtr _thumb, _locationThumb;
 
-	std_::unique_ptr<internal::SendData> sendData;
+	std::unique_ptr<internal::SendData> sendData;
 
 };
 

Telegram/SourceFiles/intro/introphone.cpp

@@ -92,7 +92,7 @@ void PhoneWidget::showSignup() {
 	if (!_signup) {
 		auto signupText = lng_phone_notreg(lt_link_start, textcmdStartLink(1), lt_link_end, textcmdStopLink(), lt_signup_start, textcmdStartLink(2), lt_signup_end, textcmdStopLink());
 		auto inner = object_ptr<Ui::FlatLabel>(this, signupText, Ui::FlatLabel::InitType::Rich, st::introDescription);
-		_signup.create(this, std_::move(inner), st::introErrorDuration);
+		_signup.create(this, std::move(inner), st::introErrorDuration);
 		_signup->entity()->setLink(1, MakeShared<UrlClickHandler>(qsl("https://telegram.org"), false));
 		_signup->entity()->setLink(2, MakeShared<LambdaClickHandler>([this] {
 			toSignUp();

Telegram/SourceFiles/intro/introwidget.cpp

@@ -209,7 +209,7 @@ void Widget::appendStep(Step *step) {
 void Widget::showResetButton() {
 	if (!_resetAccount) {
 		auto entity = object_ptr<Ui::RoundButton>(this, lang(lng_signin_reset_account), st::introResetButton);
-		_resetAccount.create(this, std_::move(entity), st::introErrorDuration);
+		_resetAccount.create(this, std::move(entity), st::introErrorDuration);
 		_resetAccount->hideFast();
 		_resetAccount->entity()->setClickedCallback([this] { resetAccount(); });
 		updateControlsGeometry();
@@ -579,7 +579,7 @@ void Widget::Step::prepareCoverMask() {
 		}
 		maskInts += maskIntsPerLineAdded;
 	}
-	_coverMask = App::pixmapFromImageInPlace(std_::move(mask));
+	_coverMask = App::pixmapFromImageInPlace(std::move(mask));
 }
 
 void Widget::Step::paintCover(Painter &p, int top) {
@@ -682,8 +682,8 @@ void Widget::Step::prepareShowAnimated(Step *after) {
 	} else {
 		auto leftSnapshot = after->prepareSlideAnimation();
 		auto rightSnapshot = prepareSlideAnimation();
-		_slideAnimation = std_::make_unique<Ui::SlideAnimation>();
+		_slideAnimation = std::make_unique<Ui::SlideAnimation>();
-		_slideAnimation->setSnapshots(std_::move(leftSnapshot), std_::move(rightSnapshot));
+		_slideAnimation->setSnapshots(std::move(leftSnapshot), std::move(rightSnapshot));
 		_slideAnimation->setOverflowHidden(false);
 	}
 }
@@ -694,7 +694,7 @@ Widget::Step::CoverAnimation Widget::Step::prepareCoverAnimation(Step *after) {
 	result.description = Ui::FlatLabel::CrossFade(after->_description->entity(), _description->entity(), st::introBg, after->_description->pos(), _description->pos());
 	result.contentSnapshotWas = after->prepareContentSnapshot();
 	result.contentSnapshotNow = prepareContentSnapshot();
-	return std_::move(result);
+	return std::move(result);
 }
 
 QPixmap Widget::Step::prepareContentSnapshot() {
@@ -721,11 +721,11 @@ void Widget::Step::showAnimated(Direction direction) {
 }
 
 void Widget::Step::setGoCallback(base::lambda<void(Step *step, Direction direction)> &&callback) {
-	_goCallback = std_::move(callback);
+	_goCallback = std::move(callback);
 }
 
 void Widget::Step::setShowResetCallback(base::lambda<void()> &&callback) {
-	_showResetCallback = std_::move(callback);
+	_showResetCallback = std::move(callback);
 }
 
 void Widget::Step::showFast() {

Telegram/SourceFiles/intro/introwidget.h

@@ -167,8 +167,8 @@ public:
 			CoverAnimation &operator=(CoverAnimation &&other) = default;
 			~CoverAnimation();
 
-			std_::unique_ptr<Ui::CrossFadeAnimation> title;
+			std::unique_ptr<Ui::CrossFadeAnimation> title;
-			std_::unique_ptr<Ui::CrossFadeAnimation> description;
+			std::unique_ptr<Ui::CrossFadeAnimation> description;
 
 			// From content top till the next button top.
 			QPixmap contentSnapshotWas;
@@ -200,7 +200,7 @@ public:
 
 		Animation _a_show;
 		CoverAnimation _coverAnimation;
-		std_::unique_ptr<Ui::SlideAnimation> _slideAnimation;
+		std::unique_ptr<Ui::SlideAnimation> _slideAnimation;
 		QPixmap _coverMask;
 
 	};

Telegram/SourceFiles/layerwidget.cpp

@@ -46,7 +46,7 @@ public:
 	}
 
 	void setDoneCallback(base::lambda<void()> &&callback) {
-		_doneCallback = std_::move(callback);
+		_doneCallback = std::move(callback);
 	}
 
 	void setLayerBoxes(const QRect &specialLayerBox, const QRect &layerBox);
@@ -98,10 +98,10 @@ private:
 };
 
 void LayerStackWidget::BackgroundWidget::setCacheImages(QPixmap &&bodyCache, QPixmap &&mainMenuCache, QPixmap &&specialLayerCache, QPixmap &&layerCache) {
-	_bodyCache = std_::move(bodyCache);
+	_bodyCache = std::move(bodyCache);
-	_mainMenuCache = std_::move(mainMenuCache);
+	_mainMenuCache = std::move(mainMenuCache);
-	_specialLayerCache = std_::move(specialLayerCache);
+	_specialLayerCache = std::move(specialLayerCache);
-	_layerCache = std_::move(layerCache);
+	_layerCache = std::move(layerCache);
 	_specialLayerCacheBox = _specialLayerBox;
 	_layerCacheBox = _layerBox;
 	setAttribute(Qt::WA_OpaquePaintEvent, !_bodyCache.isNull());
@@ -259,7 +259,7 @@ void LayerStackWidget::BackgroundWidget::paintEvent(QPaintEvent *e) {
 		// in the transparent special layer cache corners after filling special layer
 		// rect above its cache with alpha_current opacity.
 		auto region = QRegion(bg) - specialLayerBox;
-		for_const (auto rect, region.rects()) {
+		for (auto rect : region.rects()) {
 			p.fillRect(rect, st::layerBg);
 		}
 		p.setOpacity((bgOpacity - overSpecialOpacity) / (1. - (overSpecialOpacity * st::layerBg->c.alphaF())));
@@ -410,7 +410,7 @@ void LayerStackWidget::setCacheImages() {
 	}
 	setAttribute(Qt::WA_OpaquePaintEvent, !bodyCache.isNull());
 	updateLayerBoxes();
-	_background->setCacheImages(std_::move(bodyCache), std_::move(mainMenuCache), std_::move(specialLayerCache), std_::move(layerCache));
+	_background->setCacheImages(std::move(bodyCache), std::move(mainMenuCache), std::move(specialLayerCache), std::move(layerCache));
 }
 
 void LayerStackWidget::onLayerClosed(LayerWidget *layer) {
@@ -522,7 +522,7 @@ void LayerStackWidget::resizeEvent(QResizeEvent *e) {
 }
 
 void LayerStackWidget::showBox(object_ptr<BoxContent> box) {
-	auto pointer = pushBox(std_::move(box));
+	auto pointer = pushBox(std::move(box));
 	while (!_layers.isEmpty() && _layers.front() != pointer) {
 		auto removingLayer = _layers.front();
 		_layers.pop_front();
@@ -590,9 +590,9 @@ void LayerStackWidget::showFinished() {
 }
 
 void LayerStackWidget::showSpecialLayer(object_ptr<LayerWidget> layer) {
-	startAnimation([this, layer = std_::move(layer)]() mutable {
+	startAnimation([this, layer = std::move(layer)]() mutable {
 		_specialLayer.destroyDelayed();
-		_specialLayer = std_::move(layer);
+		_specialLayer = std::move(layer);
 		initChildLayer(_specialLayer);
 	}, [this] {
 		clearLayers();
@@ -612,7 +612,7 @@ void LayerStackWidget::showMainMenu() {
 }
 
 void LayerStackWidget::appendBox(object_ptr<BoxContent> box) {
-	pushBox(std_::move(box));
+	pushBox(std::move(box));
 }
 
 LayerWidget *LayerStackWidget::pushBox(object_ptr<BoxContent> box) {
@@ -621,7 +621,7 @@ LayerWidget *LayerStackWidget::pushBox(object_ptr<BoxContent> box) {
 		if (oldLayer->inFocusChain()) setFocus();
 		oldLayer->hide();
 	}
-	auto layer = object_ptr<AbstractBox>(this, std_::move(box));
+	auto layer = object_ptr<AbstractBox>(this, std::move(box));
 	_layers.push_back(layer);
 	initChildLayer(layer);
 
@@ -641,9 +641,9 @@ LayerWidget *LayerStackWidget::pushBox(object_ptr<BoxContent> box) {
 
 void LayerStackWidget::prependBox(object_ptr<BoxContent> box) {
 	if (_layers.empty()) {
-		return showBox(std_::move(box));
+		return showBox(std::move(box));
 	}
-	auto layer = object_ptr<AbstractBox>(this, std_::move(box));
+	auto layer = object_ptr<AbstractBox>(this, std::move(box));
 	layer->hide();
 	_layers.push_front(layer);
 	initChildLayer(layer);

Telegram/SourceFiles/layerwidget.h

@@ -46,10 +46,10 @@ public:
 	bool overlaps(const QRect &globalRect);
 
 	void setClosedCallback(base::lambda<void()> &&callback) {
-		_closedCallback = std_::move(callback);
+		_closedCallback = std::move(callback);
 	}
 	void setResizedCallback(base::lambda<void()> &&callback) {
-		_resizedCallback = std_::move(callback);
+		_resizedCallback = std::move(callback);
 	}
 
 protected:
@@ -208,5 +208,5 @@ private:
 template <typename BoxType, typename ...Args>
 inline object_ptr<BoxType> Box(Args&&... args) {
 	auto parent = static_cast<QWidget*>(nullptr);
-	return object_ptr<BoxType>(parent, std_::forward<Args>(args)...);
+	return object_ptr<BoxType>(parent, std::forward<Args>(args)...);
 }

Telegram/SourceFiles/layout.cpp

@@ -256,7 +256,7 @@ RoundCorners documentCorners(int32 colorIndex) {
 
 bool documentIsValidMediaFile(const QString &filepath) {
 	static StaticNeverFreedPointer<QList<QString>> validMediaTypes(([] {
-		std_::unique_ptr<QList<QString>> result = std_::make_unique<QList<QString>>();
+		std::unique_ptr<QList<QString>> result = std::make_unique<QList<QString>>();
 		*result = qsl("\
 webm mkv flv vob ogv ogg drc gif gifv mng avi mov qt wmv yuv rm rmvb asf amv mp4 m4p \
 m4v mpg mp2 mpeg mpe mpv m2v svi 3gp 3g2 mxf roq nsv f4v f4p f4a f4b wma divx evo mk3d \
@@ -276,7 +276,7 @@ dwd smp aup cust mid mus sib sid ly gym vgm psf nsf mod ptb s3m xm it mt2 minips
 
 bool documentIsExecutableName(const QString &filename) {
 	static StaticNeverFreedPointer<QList<QString>> executableTypes(([] {
-		std_::unique_ptr<QList<QString>> result = std_::make_unique<QList<QString>>();
+		std::unique_ptr<QList<QString>> result = std::make_unique<QList<QString>>();
 #ifdef Q_OS_MAC
 		*result = qsl("\
 action app bin command csh osx workflow\

Telegram/SourceFiles/localimageloader.cpp

@@ -235,7 +235,7 @@ void FileLoadTask::process() {
 			auto mimeType = mimeTypeForData(_content);
 			filemime = mimeType.name();
 			if (filemime != stickerMime) {
-				fullimage = Images::prepareOpaque(std_::move(fullimage));
+				fullimage = Images::prepareOpaque(std::move(fullimage));
 			}
 			if (filemime == "image/jpeg") {
 				filename = filedialogDefaultName(qsl("photo"), qsl(".jpg"), QString(), true);
@@ -270,7 +270,7 @@ void FileLoadTask::process() {
 			}
 			filesize = _content.size();
 		}
-		fullimage = Images::prepareOpaque(std_::move(fullimage));
+		fullimage = Images::prepareOpaque(std::move(fullimage));
 	}
 	_result->filesize = (int32)qMin(filesize, qint64(INT_MAX));
 
@@ -302,7 +302,7 @@ void FileLoadTask::process() {
 				if (!cover.isNull()) { // cover to thumb
 					int32 cw = cover.width(), ch = cover.height();
 					if (cw < 20 * ch && ch < 20 * cw) {
-						QPixmap full = (cw > 90 || ch > 90) ? App::pixmapFromImageInPlace(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : App::pixmapFromImageInPlace(std_::move(cover));
+						QPixmap full = (cw > 90 || ch > 90) ? App::pixmapFromImageInPlace(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : App::pixmapFromImageInPlace(std::move(cover));
 						{
 							QByteArray thumbFormat = "JPG";
 							int32 thumbQuality = 87;
@@ -329,7 +329,7 @@ void FileLoadTask::process() {
 					attributes.push_back(animatedAttribute);
 					gif = true;
 
-					QPixmap full = (cw > 90 || ch > 90) ? App::pixmapFromImageInPlace(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : App::pixmapFromImageInPlace(std_::move(cover));
+					QPixmap full = (cw > 90 || ch > 90) ? App::pixmapFromImageInPlace(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation)) : App::pixmapFromImageInPlace(std::move(cover));
 					{
 						QByteArray thumbFormat = "JPG";
 						int32 thumbQuality = 87;

Telegram/SourceFiles/localstorage.cpp

@@ -2550,13 +2550,13 @@ void readDraftsWithCursors(History *h) {
 		if (msgData.text.isEmpty() && !msgReplyTo) {
 			h->clearLocalDraft();
 		} else {
-			h->setLocalDraft(std_::make_unique<Data::Draft>(msgData, msgReplyTo, msgCursor, msgPreviewCancelled));
+			h->setLocalDraft(std::make_unique<Data::Draft>(msgData, msgReplyTo, msgCursor, msgPreviewCancelled));
 		}
 	}
 	if (!editMsgId) {
 		h->clearEditDraft();
 	} else {
-		h->setEditDraft(std_::make_unique<Data::Draft>(editData, editMsgId, editCursor, editPreviewCancelled));
+		h->setEditDraft(std::make_unique<Data::Draft>(editData, editMsgId, editCursor, editPreviewCancelled));
 	}
 }
 
@@ -3754,7 +3754,7 @@ bool readBackground() {
 #endif // OS_MAC_OLD
 	if (reader.read(&image)) {
 		_backgroundCanWrite = false;
-		Window::Theme::Background()->setImage(id, std_::move(image));
+		Window::Theme::Background()->setImage(id, std::move(image));
 		_backgroundCanWrite = true;
 		return true;
 	}

Telegram/SourceFiles/logs.cpp

@@ -746,7 +746,7 @@ namespace internal {
 	struct SomeAllocatedMemoryChunk {
 		char data[1024 * 1024];
 	};
-	std_::unique_ptr<SomeAllocatedMemoryChunk> SomeAllocatedMemory;
+	std::unique_ptr<SomeAllocatedMemoryChunk> SomeAllocatedMemory;
 
 	void OperatorNewHandler() {
 		std::set_new_handler(nullptr);
@@ -755,7 +755,7 @@ namespace internal {
 	}
 
 	void InstallOperatorNewHandler() {
-		SomeAllocatedMemory = std_::make_unique<SomeAllocatedMemoryChunk>();
+		SomeAllocatedMemory = std::make_unique<SomeAllocatedMemoryChunk>();
 		std::set_new_handler(OperatorNewHandler);
 	}
 

Telegram/SourceFiles/mainwidget.cpp

@@ -61,8 +61,8 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include "window/player_wrap_widget.h"
 #include "styles/style_boxes.h"
 
-StackItemSection::StackItemSection(std_::unique_ptr<Window::SectionMemento> &&memento) : StackItem(nullptr)
+StackItemSection::StackItemSection(std::unique_ptr<Window::SectionMemento> &&memento) : StackItem(nullptr)
-, _memento(std_::move(memento)) {
+, _memento(std::move(memento)) {
 }
 
 StackItemSection::~StackItemSection() {
@@ -229,7 +229,7 @@ bool MainWidget::onShareUrl(const PeerId &peer, const QString &url, const QStrin
 	History *h = App::history(peer);
 	TextWithTags textWithTags = { url + '\n' + text, TextWithTags::Tags() };
 	MessageCursor cursor = { url.size() + 1, url.size() + 1 + text.size(), QFIXED_MAX };
-	h->setLocalDraft(std_::make_unique<Data::Draft>(textWithTags, 0, cursor, false));
+	h->setLocalDraft(std::make_unique<Data::Draft>(textWithTags, 0, cursor, false));
 	h->clearEditDraft();
 	bool opened = _history->peer() && (_history->peer()->id == peer);
 	if (opened) {
@@ -249,7 +249,7 @@ bool MainWidget::onInlineSwitchChosen(const PeerId &peer, const QString &botAndQ
 	History *h = App::history(peer);
 	TextWithTags textWithTags = { botAndQuery, TextWithTags::Tags() };
 	MessageCursor cursor = { botAndQuery.size(), botAndQuery.size(), QFIXED_MAX };
-	h->setLocalDraft(std_::make_unique<Data::Draft>(textWithTags, 0, cursor, false));
+	h->setLocalDraft(std::make_unique<Data::Draft>(textWithTags, 0, cursor, false));
 	h->clearEditDraft();
 	bool opened = _history->peer() && (_history->peer()->id == peer);
 	if (opened) {
@@ -638,7 +638,7 @@ void MainWidget::hiderLayer(object_ptr<HistoryHider> h) {
 		return;
 	}
 
-	_hider = std_::move(h);
+	_hider = std::move(h);
 	connect(_hider, SIGNAL(forwarded()), _dialogs, SLOT(onCancelSearch()));
 	if (Adaptive::OneColumn()) {
 		dialogsToUp();
@@ -1104,7 +1104,7 @@ void MainWidget::onCacheBackground() {
 		}
 		_cachedX = 0;
 		_cachedY = 0;
-		_cachedBackground = App::pixmapFromImageInPlace(std_::move(result));
+		_cachedBackground = App::pixmapFromImageInPlace(std::move(result));
 	} else {
 		auto &bg = Window::Theme::Background()->pixmap();
 
@@ -1874,7 +1874,7 @@ void MainWidget::updateScrollColors() {
 }
 
 void MainWidget::setChatBackground(const App::WallPaper &wp) {
-	_background = std_::make_unique<App::WallPaper>(wp);
+	_background = std::make_unique<App::WallPaper>(wp);
 	_background->full->loadEvenCancelled();
 	checkChatBackground();
 }
@@ -2014,7 +2014,7 @@ void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QStrin
 			if (update.peer != peer) return;
 			pinAction->setText(lang(App::history(peer)->isPinnedDialog() ? lng_context_unpin_from_top : lng_context_pin_to_top));
 		});
-		*pinSubscription = Notify::PeerUpdated().add_subscription(std_::move(pinChangedHandler));
+		*pinSubscription = Notify::PeerUpdated().add_subscription(std::move(pinChangedHandler));
 	}
 	callback(lang((peer->isChat() || peer->isMegagroup()) ? lng_context_view_group : (peer->isUser() ? lng_context_view_profile : lng_context_view_channel)), [peer] {
 		Ui::showPeerProfile(peer);
@@ -2027,7 +2027,7 @@ void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QStrin
 		if (update.peer != peer) return;
 		muteAction->setText(lang(peer->isMuted() ? lng_enable_notifications_from_tray : lng_disable_notifications_from_tray));
 	});
-	*muteSubscription = Notify::PeerUpdated().add_subscription(std_::move(muteChangedHandler));
+	*muteSubscription = Notify::PeerUpdated().add_subscription(std::move(muteChangedHandler));
 
 	callback(lang(lng_profile_search_messages), [peer] {
 		App::main()->searchInPeer(peer);
@@ -2066,8 +2066,8 @@ void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QStrin
 		}));
 	};
 	if (auto user = peer->asUser()) {
-		callback(lang(lng_profile_delete_conversation), std_::move(deleteAndLeaveHandler));
+		callback(lang(lng_profile_delete_conversation), std::move(deleteAndLeaveHandler));
-		callback(lang(lng_profile_clear_history), std_::move(clearHistoryHandler));
+		callback(lang(lng_profile_clear_history), std::move(clearHistoryHandler));
 		if (!user->isInaccessible() && user != App::self()) {
 			auto blockSubscription = MakeShared<base::Subscription>();
 			auto blockAction = callback(lang(user->isBlocked() ? (user->botInfo ? lng_profile_unblock_bot : lng_profile_unblock_user) : (user->botInfo ? lng_profile_block_bot : lng_profile_block_user)), [user, blockSubscription] {
@@ -2077,26 +2077,26 @@ void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QStrin
 					emit App::main()->peerUpdated(user);
 				});
 				if (willBeBlocked) {
-					MTP::send(MTPcontacts_Block(user->inputUser), std_::move(handler));
+					MTP::send(MTPcontacts_Block(user->inputUser), std::move(handler));
 				} else {
-					MTP::send(MTPcontacts_Unblock(user->inputUser), std_::move(handler));
+					MTP::send(MTPcontacts_Unblock(user->inputUser), std::move(handler));
 				}
 			});
 			auto blockChangedHandler = Notify::PeerUpdatedHandler(Notify::PeerUpdate::Flag::UserIsBlocked, [blockAction, peer](const Notify::PeerUpdate &update) {
 				if (update.peer != peer) return;
 				blockAction->setText(lang(peer->asUser()->isBlocked() ? (peer->asUser()->botInfo ? lng_profile_unblock_bot : lng_profile_unblock_user) : (peer->asUser()->botInfo ? lng_profile_block_bot : lng_profile_block_user)));
 			});
-			*blockSubscription = Notify::PeerUpdated().add_subscription(std_::move(blockChangedHandler));
+			*blockSubscription = Notify::PeerUpdated().add_subscription(std::move(blockChangedHandler));
 
 			if (user->blockStatus() == UserData::BlockStatus::Unknown) {
 				App::api()->requestFullPeer(user);
 			}
 		}
 	} else if (peer->isChat()) {
-		callback(lang(lng_profile_clear_and_exit), std_::move(deleteAndLeaveHandler));
+		callback(lang(lng_profile_clear_and_exit), std::move(deleteAndLeaveHandler));
-		callback(lang(lng_profile_clear_history), std_::move(clearHistoryHandler));
+		callback(lang(lng_profile_clear_history), std::move(clearHistoryHandler));
 	} else if (peer->isChannel() && peer->asChannel()->amIn() && !peer->asChannel()->amCreator()) {
-		callback(lang(peer->isMegagroup() ? lng_profile_leave_group : lng_profile_leave_channel), std_::move(deleteAndLeaveHandler));
+		callback(lang(peer->isMegagroup() ? lng_profile_leave_group : lng_profile_leave_channel), std::move(deleteAndLeaveHandler));
 	}
 }
 
@@ -2398,13 +2398,13 @@ bool MainWidget::mediaTypeSwitch() {
 
 void MainWidget::saveSectionInStack() {
 	if (_overview) {
-		_stack.push_back(std_::make_unique<StackItemOverview>(_overview->peer(), _overview->type(), _overview->lastWidth(), _overview->lastScrollTop()));
+		_stack.push_back(std::make_unique<StackItemOverview>(_overview->peer(), _overview->type(), _overview->lastWidth(), _overview->lastScrollTop()));
 	} else if (_wideSection) {
-		_stack.push_back(std_::make_unique<StackItemSection>(_wideSection->createMemento()));
+		_stack.push_back(std::make_unique<StackItemSection>(_wideSection->createMemento()));
 	} else if (_history->peer()) {
 		_peerInStack = _history->peer();
 		_msgIdInStack = _history->msgId();
-		_stack.push_back(std_::make_unique<StackItemHistory>(_peerInStack, _msgIdInStack, _history->replyReturns()));
+		_stack.push_back(std::make_unique<StackItemHistory>(_peerInStack, _msgIdInStack, _history->replyReturns()));
 	}
 }
 
@@ -2608,7 +2608,7 @@ void MainWidget::showNewWideSection(const Window::SectionMemento *memento, bool
 		_wideSection->deleteLater();
 		_wideSection = nullptr;
 	}
-	_wideSection = std_::move(newWideSection);
+	_wideSection = std::move(newWideSection);
 	_topBar->hide();
 	updateControlsGeometry();
 	_history->finishAnimation();
@@ -2631,17 +2631,17 @@ bool MainWidget::isSectionShown() const {
 }
 
 bool MainWidget::stackIsEmpty() const {
-	return _stack.isEmpty();
+	return _stack.empty();
 }
 
 void MainWidget::showBackFromStack() {
 	if (selectingPeer()) return;
-	if (_stack.isEmpty()) {
+	if (_stack.empty()) {
 		Ui::showChatsList();
 		if (App::wnd()) QTimer::singleShot(0, App::wnd(), SLOT(setInnerFocus()));
 		return;
 	}
-	auto item = std_::move(_stack.back());
+	auto item = std::move(_stack.back());
 	_stack.pop_back();
 	if (auto currentHistoryPeer = _history->peer()) {
 		clearBotStartToken(currentHistoryPeer);

Telegram/SourceFiles/mainwidget.h

@@ -93,7 +93,7 @@ public:
 
 class StackItemSection : public StackItem {
 public:
-	StackItemSection(std_::unique_ptr<Window::SectionMemento> &&memento);
+	StackItemSection(std::unique_ptr<Window::SectionMemento> &&memento);
 	~StackItemSection();
 
 	StackItemType type() const {
@@ -104,7 +104,7 @@ public:
 	}
 
 private:
-	std_::unique_ptr<Window::SectionMemento> _memento;
+	std::unique_ptr<Window::SectionMemento> _memento;
 
 };
 
@@ -608,7 +608,7 @@ private:
 
 	QPointer<ConfirmBox> _forwardConfirm; // for single column layout
 	object_ptr<HistoryHider> _hider = { nullptr };
-	std_::vector_of_moveable<std_::unique_ptr<StackItem>> _stack;
+	std::vector<std::unique_ptr<StackItem>> _stack;
 	PeerData *_peerInStack = nullptr;
 	MsgId _msgIdInStack = 0;
 
@@ -693,9 +693,9 @@ private:
 	void viewsIncrementDone(QVector<MTPint> ids, const MTPVector<MTPint> &result, mtpRequestId req);
 	bool viewsIncrementFail(const RPCError &error, mtpRequestId req);
 
-	std_::unique_ptr<App::WallPaper> _background;
+	std::unique_ptr<App::WallPaper> _background;
 
-	std_::unique_ptr<ApiWrap> _api;
+	std::unique_ptr<ApiWrap> _api;
 
 	bool _resizingSide = false;
 	int _resizingSideShift = 0;

Telegram/SourceFiles/mainwindow.cpp

@@ -391,7 +391,7 @@ void MainWindow::showSpecialLayer(object_ptr<LayerWidget> layer) {
 	if (!_layerBg) {
 		_layerBg.create(bodyWidget());
 	}
-	_layerBg->showSpecialLayer(std_::move(layer));
+	_layerBg->showSpecialLayer(std::move(layer));
 }
 
 void MainWindow::showMainMenu() {
@@ -450,12 +450,12 @@ void MainWindow::ui_showBox(object_ptr<BoxContent> box, ShowLayerOptions options
 		}
 		if (options.testFlag(KeepOtherLayers)) {
 			if (options.testFlag(ShowAfterOtherLayers)) {
-				_layerBg->prependBox(std_::move(box));
+				_layerBg->prependBox(std::move(box));
 			} else {
-				_layerBg->appendBox(std_::move(box));
+				_layerBg->appendBox(std::move(box));
 			}
 		} else {
-			_layerBg->showBox(std_::move(box));
+			_layerBg->showBox(std::move(box));
 		}
 		if (options.testFlag(ForceFastShowLayer)) {
 			_layerBg->finishAnimation();

Telegram/SourceFiles/media/media_audio.cpp

@@ -777,7 +777,7 @@ void Mixer::play(const AudioMsgId &audio, int64 position) {
 	}
 }
 
-void Mixer::initFromVideo(uint64 videoPlayId, std_::unique_ptr<VideoSoundData> &&data, int64 position) {
+void Mixer::initFromVideo(uint64 videoPlayId, std::unique_ptr<VideoSoundData> &&data, int64 position) {
 	AudioMsgId stopped;
 	{
 		QMutexLocker lock(&AudioMutex);
@@ -811,7 +811,7 @@ void Mixer::initFromVideo(uint64 videoPlayId, std_::unique_ptr<VideoSoundData> &
 		current->clear();
 		current->state.id = AudioMsgId(AudioMsgId::Type::Video);
 		current->videoPlayId = videoPlayId;
-		current->videoData = std_::move(data);
+		current->videoData = std::move(data);
 		{
 			QMutexLocker videoLock(&_lastVideoMutex);
 			_lastVideoPlayId = current->videoPlayId;
@@ -947,7 +947,7 @@ void Mixer::resumeFromVideo(uint64 videoPlayId) {
 }
 
 void Mixer::feedFromVideo(VideoSoundPart &&part) {
-	_loader->feedFromVideo(std_::move(part));
+	_loader->feedFromVideo(std::move(part));
 }
 
 TimeMs Mixer::getVideoCorrectedTime(uint64 playId, TimeMs frameMs, TimeMs systemMs) {

Telegram/SourceFiles/media/media_audio.h

@@ -101,7 +101,7 @@ public:
 	void stop(AudioMsgId::Type type);
 
 	// Video player audio stream interface.
-	void initFromVideo(uint64 videoPlayId, std_::unique_ptr<VideoSoundData> &&data, int64 position);
+	void initFromVideo(uint64 videoPlayId, std::unique_ptr<VideoSoundData> &&data, int64 position);
 	void feedFromVideo(VideoSoundPart &&part);
 	int64 getVideoCorrectedTime(uint64 playId, TimeMs frameMs, TimeMs systemMs);
 	TrackState currentVideoState(uint64 videoPlayId);
@@ -183,7 +183,7 @@ private:
 		Stream stream;
 
 		uint64 videoPlayId = 0;
-		std_::unique_ptr<VideoSoundData> videoData;
+		std::unique_ptr<VideoSoundData> videoData;
 
 	private:
 		void createStream();

Telegram/SourceFiles/media/media_audio_loaders.cpp

@@ -312,7 +312,7 @@ AudioPlayerLoader *Loaders::setupLoader(const AudioMsgId &audio, SetupError &err
 	}
 
 	if (!l) {
-		std_::unique_ptr<AudioPlayerLoader> *loader = nullptr;
+		std::unique_ptr<AudioPlayerLoader> *loader = nullptr;
 		switch (audio.type()) {
 		case AudioMsgId::Type::Voice: _audio = audio; loader = &_audioLoader; break;
 		case AudioMsgId::Type::Song: _song = audio; loader = &_songLoader; break;
@@ -326,10 +326,10 @@ AudioPlayerLoader *Loaders::setupLoader(const AudioMsgId &audio, SetupError &err
 				LOG(("Audio Error: video sound data not ready"));
 				return nullptr;
 			}
-			_videoLoader = std_::make_unique<ChildFFMpegLoader>(track->videoPlayId, std_::move(track->videoData));
+			_videoLoader = std::make_unique<ChildFFMpegLoader>(track->videoPlayId, std::move(track->videoData));
 			l = _videoLoader.get();
 		} else {
-			*loader = std_::make_unique<FFMpegLoader>(track->file, track->data);
+			*loader = std::make_unique<FFMpegLoader>(track->file, track->data);
 			l = loader->get();
 		}
 

Telegram/SourceFiles/media/media_audio_loaders.h

@@ -57,9 +57,9 @@ private:
 	void clearFromVideoQueue();
 
 	AudioMsgId _audio, _song, _video;
-	std_::unique_ptr<AudioPlayerLoader> _audioLoader;
+	std::unique_ptr<AudioPlayerLoader> _audioLoader;
-	std_::unique_ptr<AudioPlayerLoader> _songLoader;
+	std::unique_ptr<AudioPlayerLoader> _songLoader;
-	std_::unique_ptr<ChildFFMpegLoader> _videoLoader;
+	std::unique_ptr<ChildFFMpegLoader> _videoLoader;
 
 	QMutex _fromVideoMutex;
 	uint64 _fromVideoPlayId;

Telegram/SourceFiles/media/media_child_ffmpeg_loader.cpp

@@ -33,9 +33,9 @@ VideoSoundData::~VideoSoundData() {
 	}
 }
 
-ChildFFMpegLoader::ChildFFMpegLoader(uint64 videoPlayId, std_::unique_ptr<VideoSoundData> &&data) : AudioPlayerLoader(FileLocation(), QByteArray())
+ChildFFMpegLoader::ChildFFMpegLoader(uint64 videoPlayId, std::unique_ptr<VideoSoundData> &&data) : AudioPlayerLoader(FileLocation(), QByteArray())
 , _videoPlayId(videoPlayId)
-, _parentData(std_::move(data)) {
+, _parentData(std::move(data)) {
 	_frame = av_frame_alloc();
 }
 
@@ -190,7 +190,7 @@ AudioPlayerLoader::ReadResult ChildFFMpegLoader::readFromReadyFrame(QByteArray &
 }
 
 void ChildFFMpegLoader::enqueuePackets(QQueue<FFMpeg::AVPacketDataWrap> &packets) {
-	_queue += std_::move(packets);
+	_queue += std::move(packets);
 	packets.clear();
 }
 

Telegram/SourceFiles/media/media_child_ffmpeg_loader.h

@@ -82,7 +82,7 @@ inline void freePacket(AVPacket *packet) {
 
 class ChildFFMpegLoader : public AudioPlayerLoader {
 public:
-	ChildFFMpegLoader(uint64 videoPlayId, std_::unique_ptr<VideoSoundData> &&data);
+	ChildFFMpegLoader(uint64 videoPlayId, std::unique_ptr<VideoSoundData> &&data);
 
 	bool open(qint64 &position) override;
 
@@ -127,7 +127,7 @@ private:
 	uint8_t **_dstSamplesData = nullptr;
 
 	uint64 _videoPlayId = 0;
-	std_::unique_ptr<VideoSoundData> _parentData;
+	std::unique_ptr<VideoSoundData> _parentData;
 	AVSampleFormat _inputFormat;
 	AVFrame *_frame = nullptr;
 

Telegram/SourceFiles/media/media_clip_ffmpeg.cpp

@@ -389,7 +389,7 @@ bool FFMpegReaderImplementation::start(Mode mode, TimeMs &positionMs) {
 		return false;
 	}
 
-	std_::unique_ptr<VideoSoundData> soundData;
+	std::unique_ptr<VideoSoundData> soundData;
 	if (_audioStreamId >= 0) {
 		AVCodecContext *audioContext = avcodec_alloc_context3(nullptr);
 		if (!audioContext) {
@@ -409,7 +409,7 @@ bool FFMpegReaderImplementation::start(Mode mode, TimeMs &positionMs) {
 			LOG(("Gif Error: Unable to avcodec_open2 %1, error %2, %3").arg(logData()).arg(res).arg(av_make_error_string(err, sizeof(err), res)));
 			_audioStreamId = -1;
 		} else {
-			soundData = std_::make_unique<VideoSoundData>();
+			soundData = std::make_unique<VideoSoundData>();
 			soundData->context = audioContext;
 			soundData->frequency = _fmtContext->streams[_audioStreamId]->codecpar->sample_rate;
 			if (_fmtContext->streams[_audioStreamId]->duration == AV_NOPTS_VALUE) {
@@ -437,7 +437,7 @@ bool FFMpegReaderImplementation::start(Mode mode, TimeMs &positionMs) {
 
 	if (_audioStreamId >= 0) {
 		auto position = (positionMs * soundData->frequency) / 1000LL;
-		Player::mixer()->initFromVideo(_playId, std_::move(soundData), position);
+		Player::mixer()->initFromVideo(_playId, std::move(soundData), position);
 	}
 
 	if (readResult == PacketResult::Ok) {
@@ -490,7 +490,7 @@ FFMpegReaderImplementation::PacketResult FFMpegReaderImplementation::readPacket(
 				VideoSoundPart part;
 				part.packet = &_packetNull;
 				part.videoPlayId = _playId;
-				Player::mixer()->feedFromVideo(std_::move(part));
+				Player::mixer()->feedFromVideo(std::move(part));
 			}
 			return PacketResult::EndOfFile;
 		}
@@ -516,7 +516,7 @@ void FFMpegReaderImplementation::processPacket(AVPacket *packet) {
 			VideoSoundPart part;
 			part.packet = packet;
 			part.videoPlayId = _playId;
-			Player::mixer()->feedFromVideo(std_::move(part));
+			Player::mixer()->feedFromVideo(std::move(part));
 		}
 	} else {
 		av_packet_unref(packet);

Telegram/SourceFiles/media/media_clip_reader.cpp

@@ -86,7 +86,7 @@ QPixmap _prepareFrame(const FrameRequest &request, const QImage &original, bool
 } // namespace
 
 Reader::Reader(const FileLocation &location, const QByteArray &data, Callback &&callback, Mode mode, int64 seekMs)
-: _callback(std_::move(callback))
+: _callback(std::move(callback))
 , _mode(mode)
 , _playId(rand_value<uint64>())
 , _seekPositionMs(seekMs) {
@@ -336,7 +336,7 @@ public:
 	, _seekPositionMs(reader->seekPositionMs())
 	, _data(data) {
 		if (_data.isEmpty()) {
-			_location = std_::make_unique<FileLocation>(location);
+			_location = std::make_unique<FileLocation>(location);
 			if (!_location->accessEnable()) {
 				error();
 				return;
@@ -357,7 +357,7 @@ public:
 
 				auto firstFramePlayId = 0LL;
 				auto firstFramePositionMs = 0LL;
-				auto reader = std_::make_unique<internal::FFMpegReaderImplementation>(_location.get(), &_data, firstFramePlayId);
+				auto reader = std::make_unique<internal::FFMpegReaderImplementation>(_location.get(), &_data, firstFramePlayId);
 				if (reader->start(internal::ReaderImplementation::Mode::Normal, firstFramePositionMs)) {
 					auto firstFrameReadResult = reader->readFramesTill(-1, ms);
 					if (firstFrameReadResult == internal::ReaderImplementation::ReadResult::Success) {
@@ -464,7 +464,7 @@ public:
 			}
 		}
 
-		_implementation = std_::make_unique<internal::FFMpegReaderImplementation>(_location.get(), &_data, _playId);
+		_implementation = std::make_unique<internal::FFMpegReaderImplementation>(_location.get(), &_data, _playId);
 //		_implementation = new QtGifReaderImplementation(_location, &_data);
 
 		auto implementationMode = [this]() {
@@ -530,11 +530,11 @@ private:
 	TimeMs _seekPositionMs = 0;
 
 	QByteArray _data;
-	std_::unique_ptr<FileLocation> _location;
+	std::unique_ptr<FileLocation> _location;
 	bool _accessed = false;
 
 	QBuffer _buffer;
-	std_::unique_ptr<internal::ReaderImplementation> _implementation;
+	std::unique_ptr<internal::ReaderImplementation> _implementation;
 
 	FrameRequest _request;
 	struct Frame {
@@ -839,7 +839,7 @@ MTPDocumentAttribute readAttributes(const QString &fname, const QByteArray &data
 
 	auto playId = 0ULL;
 	auto seekPositionMs = 0LL;
-	auto reader = std_::make_unique<internal::FFMpegReaderImplementation>(&localloc, &localdata, playId);
+	auto reader = std::make_unique<internal::FFMpegReaderImplementation>(&localloc, &localdata, playId);
 	if (reader->start(internal::ReaderImplementation::Mode::OnlyGifv, seekPositionMs)) {
 		bool hasAlpha = false;
 		auto readResult = reader->readFramesTill(-1, getms());

Telegram/SourceFiles/media/media_clip_reader.h

@@ -175,7 +175,7 @@ private:
 
 template <typename ...Args>
 inline ReaderPointer MakeReader(Args&&... args) {
-	return ReaderPointer(new Reader(std_::forward<Args>(args)...));
+	return ReaderPointer(new Reader(std::forward<Args>(args)...));
 }
 
 enum class ProcessResult {

Telegram/SourceFiles/media/player/media_player_button.cpp

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

Telegram/SourceFiles/media/player/media_player_cover.cpp

@@ -73,7 +73,7 @@ CoverWidget::CoverWidget(QWidget *parent) : TWidget(parent)
 , _nameLabel(this, st::mediaPlayerName)
 , _timeLabel(this, st::mediaPlayerTime)
 , _close(this, st::mediaPlayerPanelClose)
-, _playback(std_::make_unique<Clip::Playback>(new Ui::MediaSlider(this, st::mediaPlayerPanelPlayback)))
+, _playback(std::make_unique<Clip::Playback>(new Ui::MediaSlider(this, st::mediaPlayerPanelPlayback)))
 , _playPause(this)
 , _volumeToggle(this, st::mediaPlayerVolumeToggle)
 , _volumeController(this)
@@ -127,11 +127,11 @@ CoverWidget::CoverWidget(QWidget *parent) : TWidget(parent)
 }
 
 void CoverWidget::setPinCallback(ButtonCallback &&callback) {
-	_pinPlayer->setClickedCallback(std_::move(callback));
+	_pinPlayer->setClickedCallback(std::move(callback));
 }
 
 void CoverWidget::setCloseCallback(ButtonCallback &&callback) {
-	_close->setClickedCallback(std_::move(callback));
+	_close->setClickedCallback(std::move(callback));
 }
 
 void CoverWidget::handleSeekProgress(float64 progress) {

Telegram/SourceFiles/media/player/media_player_cover.h

@@ -80,7 +80,7 @@ private:
 	object_ptr<Ui::FlatLabel> _nameLabel;
 	object_ptr<Ui::LabelSimple> _timeLabel;
 	object_ptr<Ui::IconButton> _close;
-	std_::unique_ptr<Clip::Playback> _playback;
+	std::unique_ptr<Clip::Playback> _playback;
 	object_ptr<Ui::IconButton> _previousTrack = { nullptr };
 	object_ptr<PlayButton> _playPause;
 	object_ptr<Ui::IconButton> _nextTrack = { nullptr };

Telegram/SourceFiles/media/player/media_player_panel.cpp

@@ -222,14 +222,14 @@ void Panel::ensureCreated() {
 
 	if (_layout == Layout::Full) {
 		_cover.create(this);
-		setPinCallback(std_::move(_pinCallback));
+		setPinCallback(std::move(_pinCallback));
-		setCloseCallback(std_::move(_closeCallback));
+		setCloseCallback(std::move(_closeCallback));
 
 		_scrollShadow.create(this, st::mediaPlayerScrollShadow, Ui::Shadow::Side::Bottom);
 	}
 	auto list = object_ptr<ListWidget>(this);
 	connect(list, SIGNAL(heightUpdated()), this, SLOT(onListHeightUpdated()));
-	_scroll->setOwnedWidget(std_::move(list));
+	_scroll->setOwnedWidget(std::move(list));
 
 	if (cPlatform() == dbipMac || cPlatform() == dbipMacOld) {
 		if (auto window = App::wnd()) {
@@ -256,14 +256,14 @@ void Panel::performDestroy() {
 }
 
 void Panel::setPinCallback(ButtonCallback &&callback) {
-	_pinCallback = std_::move(callback);
+	_pinCallback = std::move(callback);
 	if (_cover) {
 		_cover->setPinCallback(ButtonCallback(_pinCallback));
 	}
 }
 
 void Panel::setCloseCallback(ButtonCallback &&callback) {
-	_closeCallback = std_::move(callback);
+	_closeCallback = std::move(callback);
 	if (_cover) {
 		_cover->setCloseCallback(ButtonCallback(_closeCallback));
 	}

Telegram/SourceFiles/media/player/media_player_widget.cpp

@@ -92,7 +92,7 @@ Widget::Widget(QWidget *parent) : TWidget(parent)
 , _repeatTrack(this, st::mediaPlayerRepeatButton)
 , _close(this, st::mediaPlayerClose)
 , _shadow(this, st::shadowFg)
-, _playback(std_::make_unique<Clip::Playback>(new Ui::FilledSlider(this, st::mediaPlayerPlayback))) {
+, _playback(std::make_unique<Clip::Playback>(new Ui::FilledSlider(this, st::mediaPlayerPlayback))) {
 	setAttribute(Qt::WA_OpaquePaintEvent);
 	setMouseTracking(true);
 	resize(width(), st::mediaPlayerHeight + st::lineWidth);
@@ -157,7 +157,7 @@ void Widget::updateVolumeToggleIcon() {
 }
 
 void Widget::setCloseCallback(CloseCallback &&callback) {
-	_close->setClickedCallback(std_::move(callback));
+	_close->setClickedCallback(std::move(callback));
 }
 
 void Widget::setShadowGeometryToLeft(int x, int y, int w, int h) {

Telegram/SourceFiles/media/player/media_player_widget.h

@@ -101,7 +101,7 @@ private:
 	object_ptr<Ui::IconButton> _repeatTrack;
 	object_ptr<Ui::IconButton> _close;
 	object_ptr<Ui::PlainShadow> _shadow = { nullptr };
-	std_::unique_ptr<Clip::Playback> _playback;
+	std::unique_ptr<Clip::Playback> _playback;
 
 };
 

Telegram/SourceFiles/media/view/media_clip_controller.cpp

@@ -35,12 +35,12 @@ namespace Clip {
 
 Controller::Controller(QWidget *parent) : TWidget(parent)
 , _playPauseResume(this, st::mediaviewPlayButton)
-, _playback(std_::make_unique<Playback>(new Ui::MediaSlider(this, st::mediaviewPlayback)))
+, _playback(std::make_unique<Playback>(new Ui::MediaSlider(this, st::mediaviewPlayback)))
 , _volumeController(this)
 , _fullScreenToggle(this, st::mediaviewFullScreenButton)
 , _playedAlready(this, st::mediaviewPlayProgressLabel)
 , _toPlayLeft(this, st::mediaviewPlayProgressLabel)
-, _fadeAnimation(std_::make_unique<Ui::FadeAnimation>(this)) {
+, _fadeAnimation(std::make_unique<Ui::FadeAnimation>(this)) {
 	_fadeAnimation->show();
 	_fadeAnimation->setFinishedCallback([this] { fadeFinished(); });
 	_fadeAnimation->setUpdatedCallback([this](float64 opacity) { fadeUpdated(opacity); });

Telegram/SourceFiles/media/view/media_clip_controller.h

@@ -86,13 +86,13 @@ private:
 	TimeMs _lastDurationMs = 0;
 
 	object_ptr<Ui::IconButton> _playPauseResume;
-	std_::unique_ptr<Playback> _playback;
+	std::unique_ptr<Playback> _playback;
 	object_ptr<VolumeController> _volumeController;
 	object_ptr<Ui::IconButton> _fullScreenToggle;
 	object_ptr<Ui::LabelSimple> _playedAlready;
 	object_ptr<Ui::LabelSimple> _toPlayLeft;
 
-	std_::unique_ptr<Ui::FadeAnimation> _fadeAnimation;
+	std::unique_ptr<Ui::FadeAnimation> _fadeAnimation;
 
 };
 

Telegram/SourceFiles/media/view/media_clip_playback.h

@@ -40,10 +40,10 @@ public:
 		_slider->setFadeOpacity(opacity);
 	}
 	void setChangeProgressCallback(Ui::ContinuousSlider::Callback &&callback) {
-		_slider->setChangeProgressCallback(std_::move(callback));
+		_slider->setChangeProgressCallback(std::move(callback));
 	}
 	void setChangeFinishedCallback(Ui::ContinuousSlider::Callback &&callback) {
-		_slider->setChangeFinishedCallback(std_::move(callback));
+		_slider->setChangeFinishedCallback(std::move(callback));
 	}
 	void setGeometry(int x, int y, int w, int h) {
 		_slider->setGeometry(x, y, w, h);

Telegram/SourceFiles/mediaview.cpp

@@ -1405,7 +1405,7 @@ void MediaView::createClipReader() {
 		_current = _doc->thumb->pixNoCache(_doc->thumb->width(), _doc->thumb->height(), Images::Option::Smooth | Images::Option::Blurred, st::mediaviewFileIconSize, st::mediaviewFileIconSize);
 	}
 	auto mode = _doc->isVideo() ? Media::Clip::Reader::Mode::Video : Media::Clip::Reader::Mode::Gif;
-	_gif = std_::make_unique<Media::Clip::Reader>(_doc->location(), _doc->data(), [this](Media::Clip::Notification notification) {
+	_gif = std::make_unique<Media::Clip::Reader>(_doc->location(), _doc->data(), [this](Media::Clip::Notification notification) {
 		clipCallback(notification);
 	}, mode);
 
@@ -1425,19 +1425,19 @@ void MediaView::initThemePreview() {
 		_themePreviewShown = true;
 		auto path = _doc->location().name();
 		auto id = _themePreviewId = rand_value<uint64>();
-		auto ready = base::lambda_guarded(this, [this, id](std_::unique_ptr<Window::Theme::Preview> result) {
+		auto ready = base::lambda_guarded(this, [this, id](std::unique_ptr<Window::Theme::Preview> result) {
 			if (id != _themePreviewId) {
 				return;
 			}
 			_themePreviewId = 0;
-			_themePreview = std_::move(result);
+			_themePreview = std::move(result);
 			if (_themePreview) {
 				_themeApply.create(this, lang(lng_theme_preview_apply), st::themePreviewApplyButton);
 				_themeApply->show();
 				_themeApply->setClickedCallback([this] {
-					auto preview = std_::move(_themePreview);
+					auto preview = std::move(_themePreview);
 					close();
-					Window::Theme::Apply(std_::move(preview));
+					Window::Theme::Apply(std::move(preview));
 				});
 				_themeCancel.create(this, lang(lng_cancel), st::themePreviewCancelButton);
 				_themeCancel->show();
@@ -1447,23 +1447,23 @@ void MediaView::initThemePreview() {
 			update();
 		});
 		struct mutable_ready {
-			mutable_ready(decltype(ready) value) : value(std_::move(value)) {
+			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_result(std::unique_ptr<Window::Theme::Preview> value) : value(std::move(value)) {
 			}
-			mutable std_::unique_ptr<Window::Theme::Preview> 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([path, current, callback = mutable_ready(std::move(ready))]() {
 			auto preview = Window::Theme::GeneratePreview(path, current);
-			base::TaskQueue::Main().Put([result = mutable_result(std_::move(preview)), callback = std_::move(callback.value)]() {
+			base::TaskQueue::Main().Put([result = mutable_result(std::move(preview)), callback = std::move(callback.value)]() {
-				callback(std_::move(result.value));
+				callback(std::move(result.value));
 			});
 		});
 		location.accessDisable();
@@ -1528,7 +1528,7 @@ void MediaView::restartVideoAtSeekPosition(TimeMs positionMs) {
 	if (_current.isNull()) {
 		_current = _gif->current(_gif->width() / cIntRetinaFactor(), _gif->height() / cIntRetinaFactor(), _gif->width() / cIntRetinaFactor(), _gif->height() / cIntRetinaFactor(), ImageRoundRadius::None, ImageRoundCorner::None, getms());
 	}
-	_gif = std_::make_unique<Media::Clip::Reader>(_doc->location(), _doc->data(), [this](Media::Clip::Notification notification) {
+	_gif = std::make_unique<Media::Clip::Reader>(_doc->location(), _doc->data(), [this](Media::Clip::Notification notification) {
 		clipCallback(notification);
 	}, Media::Clip::Reader::Mode::Video, positionMs);
 

Telegram/SourceFiles/mediaview.h

@@ -256,7 +256,7 @@ private:
 	bool _pressed = false;
 	int32 _dragging = 0;
 	QPixmap _current;
-	std_::unique_ptr<Media::Clip::Reader> _gif;
+	std::unique_ptr<Media::Clip::Reader> _gif;
 	int32 _full = -1; // -1 - thumb, 0 - medium, 1 - full
 
 	// Video without audio stream playback information.
@@ -365,7 +365,7 @@ private:
 	bool _themePreviewShown = false;
 	uint64 _themePreviewId = 0;
 	QRect _themePreviewRect;
-	std_::unique_ptr<Window::Theme::Preview> _themePreview;
+	std::unique_ptr<Window::Theme::Preview> _themePreview;
 	object_ptr<Ui::RoundButton> _themeApply = { nullptr };
 	object_ptr<Ui::RoundButton> _themeCancel = { nullptr };
 

Telegram/SourceFiles/mtproto/connection.cpp

@@ -2383,8 +2383,8 @@ void ConnectionPrivate::updateAuthKey() 	{
 		return authKeyCreated();
 	}
 
-	_authKeyData = std_::make_unique<ConnectionPrivate::AuthKeyCreateData>();
+	_authKeyData = std::make_unique<ConnectionPrivate::AuthKeyCreateData>();
-	_authKeyStrings = std_::make_unique<ConnectionPrivate::AuthKeyCreateStrings>();
+	_authKeyStrings = std::make_unique<ConnectionPrivate::AuthKeyCreateStrings>();
 	_authKeyData->req_num = 0;
 	_authKeyData->nonce = rand_value<MTPint128>();
 

Telegram/SourceFiles/mtproto/connection.h

@@ -262,8 +262,8 @@ private:
 		QByteArray dh_prime;
 		QByteArray g_a;
 	};
-	std_::unique_ptr<AuthKeyCreateData> _authKeyData;
+	std::unique_ptr<AuthKeyCreateData> _authKeyData;
-	std_::unique_ptr<AuthKeyCreateStrings> _authKeyStrings;
+	std::unique_ptr<AuthKeyCreateStrings> _authKeyStrings;
 
 	void dhClientParamsSend();
 	void authKeyCreated();

Telegram/SourceFiles/mtproto/file_download.cpp

@@ -98,7 +98,7 @@ void FileLoader::readImage(const QSize &shrinkBox) const {
 		if (!shrinkBox.isEmpty() && (image.width() > shrinkBox.width() || image.height() > shrinkBox.height())) {
 			_imagePixmap = App::pixmapFromImageInPlace(image.scaled(shrinkBox, Qt::KeepAspectRatio, Qt::SmoothTransformation));
 		} else {
-			_imagePixmap = App::pixmapFromImageInPlace(std_::move(image));
+			_imagePixmap = App::pixmapFromImageInPlace(std::move(image));
 		}
 		_imageFormat = format;
 	}

Telegram/SourceFiles/mtproto/rpc_sender.h

@@ -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:
@@ -907,37 +907,37 @@ public:
 
 template <typename R>
 inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*)> &&lambda) {
-	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBare<R>(std_::move(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) {
-	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBareReq<R>(std_::move(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) {
-	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationPlain<R, T>(std_::move(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) {
-	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationReq<R, T>(std_::move(lambda)));
+	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationReq<R, T>(std::move(lambda)));
 }
 
 template <typename R>
 inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R()> &&lambda) {
-	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNo<R>(std_::move(lambda)));
+	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNo<R>(std::move(lambda)));
 }
 
 template <typename R>
 inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(mtpRequestId)> &&lambda) {
-	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNoReq<R>(std_::move(lambda)));
+	return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNoReq<R>(std::move(lambda)));
 }
 
-template <typename Lambda, typename = std_::enable_if_t<std_::is_rvalue_reference<Lambda&&>::value>>
+template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>>
 RPCDoneHandlerPtr rpcDone(Lambda &&lambda) {
-	return rpcDone_lambda_wrap_helper(base::lambda_type<Lambda>(std_::move(lambda)));
+	return rpcDone_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda)));
 }
 
 template <typename FunctionType>
@@ -980,22 +980,22 @@ public:
 };
 
 inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&)> &&lambda) {
-	return RPCFailHandlerPtr(new RPCFailHandlerImplementationPlain(std_::move(lambda)));
+	return RPCFailHandlerPtr(new RPCFailHandlerImplementationPlain(std::move(lambda)));
 }
 
 inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&, mtpRequestId)> &&lambda) {
-	return RPCFailHandlerPtr(new RPCFailHandlerImplementationReq(std_::move(lambda)));
+	return RPCFailHandlerPtr(new RPCFailHandlerImplementationReq(std::move(lambda)));
 }
 
 inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool()> &&lambda) {
-	return RPCFailHandlerPtr(new RPCFailHandlerImplementationNo(std_::move(lambda)));
+	return RPCFailHandlerPtr(new RPCFailHandlerImplementationNo(std::move(lambda)));
 }
 
 inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(mtpRequestId)> &&lambda) {
-	return RPCFailHandlerPtr(new RPCFailHandlerImplementationNoReq(std_::move(lambda)));
+	return RPCFailHandlerPtr(new RPCFailHandlerImplementationNoReq(std::move(lambda)));
 }
 
-template <typename Lambda, typename = std_::enable_if_t<std_::is_rvalue_reference<Lambda&&>::value>>
+template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>>
 RPCFailHandlerPtr rpcFail(Lambda &&lambda) {
-	return rpcFail_lambda_wrap_helper(base::lambda_type<Lambda>(std_::move(lambda)));
+	return rpcFail_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda)));
 }