buffer: implement move semantics properly

Default implementations of move semantics are not suitable - let's
implement proper ones. Along the way, do not accept allocator in
constructor by reference since buffer stores its own copy - let's
consumer it, and to do so, we should accept rvalue reference there.

Part of #110

Author: drewdzzz

src/Buffer/Buffer.hpp

@@ -115,6 +115,12 @@ class Buffer
 	 * to the next byte after the last valid byte in block.
 	 * */
 	bool isEndOfBlock(const char *ptr);
+	/** Delete blocks and release occupied memory. */
+	void releaseBlocks(void)
+	{
+		while (!m_blocks.isEmpty())
+			delBlock(&m_blocks.first());
+	}
 
 public:
 	/** =============== Convenient wrappers =============== */
@@ -265,11 +271,35 @@ class Buffer
 
 	/** =============== Buffer definition =============== */
 	/** Copy of any kind is disabled. Move is allowed. */
-	Buffer(const allocator& all = allocator());
+	Buffer(allocator &&all = allocator());
 	Buffer(const Buffer& buf) = delete;
 	Buffer& operator = (const Buffer& buf) = delete;
-	Buffer(Buffer &&buf) noexcept = default;
-	Buffer &operator=(Buffer &&buf) noexcept = default;
+	Buffer(Buffer &&other) noexcept
+	{
+		/* Call move assignment operator. */
+		*this = std::forward<Buffer>(other);
+	}
+	Buffer &operator=(Buffer &&other)
+	{
+		if (this == &other)
+			return *this;
+
+		m_blocks = std::move(other.m_blocks);
+		/*
+		 * Release blocks of `other` right on the move because
+		 * we are going to move its allocator as well and we
+		 * shouldn't use it after it is moved.
+		 */
+		other.releaseBlocks();
+		m_all = std::move(other.m_all);
+
+		m_iterators = std::move(other.m_iterators);
+		m_begin = other.m_begin;
+		other.m_begin = nullptr;
+		m_end = other.m_end;
+		other.m_end = nullptr;
+		return *this;
+	}
 	~Buffer() noexcept;
 
 	/**
@@ -648,7 +678,7 @@ Buffer<N, allocator>::iterator_common<LIGHT>::moveBackward(size_t step)
 }
 
 template <size_t N, class allocator>
-Buffer<N, allocator>::Buffer(const allocator &all) : m_all(all)
+Buffer<N, allocator>::Buffer(allocator &&all) : m_all(std::forward<allocator>(all))
 {
 	static_assert((N & (N - 1)) == 0, "N must be power of 2");
 	static_assert(allocator::REAL_SIZE % alignof(Block) == 0,
@@ -666,9 +696,7 @@ Buffer<N, allocator>::Buffer(const allocator &all) : m_all(all)
 template <size_t N, class allocator>
 Buffer<N, allocator>::~Buffer() noexcept
 {
-	/* Delete blocks and release occupied memory. */
-	while (!m_blocks.isEmpty())
-		delBlock(&m_blocks.first());
+	releaseBlocks();
 }
 
 template <size_t N, class allocator>