UniquePointer backported. Fixed unifying of adding new history items.

Telegram/SourceFiles/history.cpp

@@ -752,7 +752,7 @@ HistoryItem *ChannelHistory::addNewToBlocks(const MTPMessage &msg, NewMessageTyp
 		HistoryItem *item = addToHistory(msg);
 
 		t_assert(!isBuildingFrontBlock());
-		addMessageGroup([item, this](HistoryItem *previous) -> HistoryItem* { // create(..)
+		addMessageGroup([item, this](HistoryItem *previous) -> HistoryGroup* { // create(..)
 			return HistoryGroup::create(this, item, previous ? previous->date : item->date);
 		}, [item](HistoryGroup *existing) { // unite(..)
 			existing->uniteWith(item);
@@ -819,7 +819,7 @@ void ChannelHistory::switchMode() {
 	oldLoaded = _otherOldLoaded;
 	if (int count = _otherList.size()) {
 		blocks.reserve((count / MessagesPerPage) + 1);
-		for (int i = 0; i < count;) {
+		for (int i = 0; i < count; ++i) {
 			t_assert(_otherList.at(i)->detached());
 			addItemToBlock(_otherList.at(i));
 		}
@@ -1652,13 +1652,13 @@ void History::newItemAdded(HistoryItem *item) {
 
 HistoryBlock *History::prepareBlockForAddingItem() {
 	if (isBuildingFrontBlock()) {
-		if (_frontBlock->block) {
+		if (_buildingFrontBlock->block) {
-			return _frontBlock->block;
+			return _buildingFrontBlock->block;
 		}
 
-		HistoryBlock *result = _frontBlock->block = new HistoryBlock(this);
+		HistoryBlock *result = _buildingFrontBlock->block = new HistoryBlock(this);
-		if (_frontBlock->expectedItemsCount > 0) {
+		if (_buildingFrontBlock->expectedItemsCount > 0) {
-			result->items.reserve(_frontBlock->expectedItemsCount + 1);
+			result->items.reserve(_buildingFrontBlock->expectedItemsCount + 1);
 		}
 		result->setIndexInHistory(0);
 		blocks.push_front(result);
@@ -1691,8 +1691,8 @@ void History::addItemToBlock(HistoryItem *item) {
 	block->items.push_back(item);
 	item->previousItemChanged();
 
-	if (isBuildingFrontBlock() && _frontBlock->expectedItemsCount > 0) {
+	if (isBuildingFrontBlock() && _buildingFrontBlock->expectedItemsCount > 0) {
-		--_frontBlock->expectedItemsCount;
+		--_buildingFrontBlock->expectedItemsCount;
 	}
 }
 
@@ -2163,8 +2163,8 @@ template <typename CreateGroup, typename UniteGroup>
 void History::addMessageGroup(CreateGroup create, UniteGroup unite) {
 	HistoryItem *previous = nullptr;
 	if (isBuildingFrontBlock()) {
-		if (_frontBlock->block) {
+		if (_buildingFrontBlock->block) {
-			previous = _frontBlock->block->items.back();
+			previous = _buildingFrontBlock->block->items.back();
 		}
 	} else {
 		if (!blocks.isEmpty()) {
@@ -2174,19 +2174,13 @@ void History::addMessageGroup(CreateGroup create, UniteGroup unite) {
 
 	if (previous && previous->type() == HistoryItemGroup) {
 		unite(static_cast<HistoryGroup*>(previous));
-		return;
-	}
-
-	HistoryGroup *result = create(previous);
-	if (isBuildingFrontBlock()) {
-		addItemToBuildingFrontBlock(result);
 	} else {
-		addItemToBackBlock(result);
+		addItemToBlock(create(previous));
 	}
 }
 
 void History::addMessageGroup(const MTPDmessageGroup &group) {
-	addMessageGroup([&group, this](HistoryItem *previous) -> HistoryItem* { // create(..)
+	addMessageGroup([&group, this](HistoryItem *previous) -> HistoryGroup* { // create(..)
 		return HistoryGroup::create(this, group, previous ? previous->date : date(group.vdate));
 	}, [&group](HistoryGroup *existing) { // unite(..)
 		existing->uniteWith(group.vmin_id.v, group.vmax_id.v, group.vcount.v);
@@ -2197,15 +2191,15 @@ void History::startBuildingFrontBlock(int expectedItemsCount) {
 	t_assert(!isBuildingFrontBlock());
 	t_assert(expectedItemsCount > 0);
 
-	_frontBlock.reset(new BuildingBlock());
+	_buildingFrontBlock.reset(new BuildingBlock());
-	_frontBlock->expectedItemsCount = expectedItemsCount;
+	_buildingFrontBlock->expectedItemsCount = expectedItemsCount;
 }
 
 HistoryBlock *History::finishBuildingFrontBlock() {
 	t_assert(isBuildingFrontBlock());
 
 	// Some checks if there was some message history already
-	HistoryBlock *block = _frontBlock->block;
+	HistoryBlock *block = _buildingFrontBlock->block;
 	if (block && blocks.size() > 1) {
 		HistoryItem *last = block->items.back(); // ... item, item, item, last ], [ first, item, item ...
 		HistoryItem *first = blocks.at(1)->items.front();
@@ -2223,11 +2217,11 @@ HistoryBlock *History::finishBuildingFrontBlock() {
 
 			// last->destroy() could've destroyed this new block
 			// so we can't rely on this pointer any more
-			block = _frontBlock->block;
+			block = _buildingFrontBlock->block;
 		}
 	}
 
-	_frontBlock.clear();
+	_buildingFrontBlock.clear();
 	return block;
 }
 
@@ -2605,8 +2599,8 @@ void History::changeMsgId(MsgId oldId, MsgId newId) {
 void History::removeBlock(HistoryBlock *block) {
 	t_assert(block->items.isEmpty());
 
-	if (_frontBlock && block == _frontBlock->block) {
+	if (_buildingFrontBlock && block == _buildingFrontBlock->block) {
-		_frontBlock->block = nullptr;
+		_buildingFrontBlock->block = nullptr;
 	}
 
 	int index = block->indexInHistory();

Telegram/SourceFiles/history.h

@@ -1049,9 +1049,9 @@ struct HistoryMessageReply : public BaseComponent<HistoryMessageReply> {
 	HistoryMessageReply &operator=(HistoryMessageReply &&other) {
 		replyToMsgId = other.replyToMsgId;
 		std::swap(replyToMsg, other.replyToMsg);
-		replyToLnk = std11::move(other.replyToLnk);
+		replyToLnk = std_::move(other.replyToLnk);
-		replyToName = std11::move(other.replyToName);
+		replyToName = std_::move(other.replyToName);
-		replyToText = std11::move(other.replyToText);
+		replyToText = std_::move(other.replyToText);
 		replyToVersion = other.replyToVersion;
 		_maxReplyWidth = other._maxReplyWidth;
 		std::swap(_replyToVia, other._replyToVia);

Telegram/SourceFiles/mtproto/connection.cpp

@@ -62,7 +62,7 @@ bool parsePQ(const string &pqStr, string &pStr, string &qStr) {
 			break;
 		}
 	}
-	if (p > q) swap(p, q);
+	if (p > q) std::swap(p, q);
 
 	pStr.resize(4);
 	uchar *pChars = (uchar*)&pStr[0];

Telegram/SourceFiles/types.h

@@ -215,31 +215,86 @@ typedef double float64;
 
 using std::string;
 using std::exception;
-using std::swap;
 
-// we copy some parts of C++11 std:: library, because on OS X 10.6+
+// we copy some parts of C++11/14/17 std:: library, because on OS X 10.6+
-// version we can use C++11, but we can't use its library :(
+// version we can use C++11/14/17, but we can not use its library :(
-namespace std11 {
+namespace std_ {
+
+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 {
-	typedef T type;
+	using type = T;
 };
 template <typename T>
 struct remove_reference<T&> {
-	typedef T type;
+	using type = T;
 };
 template <typename T>
 struct remove_reference<T&&> {
-	typedef T type;
+	using type = T;
 };
 
 template <typename T>
-inline typename remove_reference<T>::type &&move(T &&value) {
+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);
 }
 
-} // namespace std11
+template <typename T>
+struct add_const {
+	using type = const T;
+};
+template <typename T>
+using add_const_t = typename add_const<T>::type;
+template <typename T>
+constexpr add_const_t<T> &as_const(T& t) noexcept {
+	return t;
+}
+template <typename T>
+void as_const(const T&&) = delete;
+
+} // namespace std_
 
 #include "logs.h"
 
@@ -669,6 +724,66 @@ inline RefPairImplementation<T1, T2> RefPairCreator(T1 &first, T2 &second) {
 
 #define RefPair(Type1, Name1, Type2, Name2) Type1 Name1; Type2 Name2; RefPairCreator(Name1, Name2)
 
+template <typename T>
+class UniquePointer {
+public:
+	explicit UniquePointer(T *p = nullptr) : _p(p) {
+	}
+	UniquePointer(const UniquePointer<T> &other) = delete;
+	UniquePointer &operator=(const UniquePointer<T> &other) = delete;
+	UniquePointer(UniquePointer<T> &&other) : _p(other.release()) {
+	}
+	UniquePointer &operator=(UniquePointer<T> &&other) {
+		std::swap(_p, other._p);
+		return *this;
+	}
+	template <typename U>
+	UniquePointer(UniquePointer<U> &&other) : _p(other.release()) {
+	}
+	T *data() const {
+		return _p;
+	}
+	T *release() {
+		return getPointerAndReset(_p);
+	}
+	void reset(T *p = nullptr) {
+		*this = UniquePointer<T>(p);
+	}
+	bool isNull() const {
+		return data() == nullptr;
+	}
+
+	void clear() {
+		reset();
+	}
+	T *operator->() const {
+		return data();
+	}
+	T &operator*() const {
+		t_assert(!isNull());
+		return *data();
+	}
+	explicit operator bool() const {
+		return !isNull();
+	}
+	~UniquePointer() {
+		delete data();
+	}
+
+private:
+	T *_p;
+
+};
+template <typename T, class... Args>
+inline UniquePointer<T> MakeUnique(Args&&... args) {
+	return UniquePointer<T>(new T(std_::forward<Args>(args)...));
+}
+
+template <typename T, class... Args>
+inline QSharedPointer<T> MakeShared(Args&&... args) {
+	return QSharedPointer<T>(new T(std_::forward<Args>(args)...));
+}
+
 template <typename I>
 inline void destroyImplementation(I *&ptr) {
 	if (ptr) {
@@ -715,7 +830,7 @@ struct ComponentWrapTemplate {
 		((Type*)location)->~Type();
 	}
 	static void Move(void *location, void *waslocation) {
-		*(Type*)location = std11::move(*(Type*)waslocation);
+		*(Type*)location = std_::move(*(Type*)waslocation);
 	}
 };