Implementation of move semantics for Firebird::string (#8059)

Author: Noremos

src/common/classes/alloc.h

@@ -232,6 +232,16 @@ friend class ExternalMemoryHandler;
 	// The same routine, but more easily callable from the debugger
 	void print_contents(const char* filename, unsigned flags = 0, const char* filter_path = 0) noexcept;
 
+	inline bool operator==(const MemoryPool& rhs) const
+	{
+		return pool == rhs.pool;
+	}
+
+	inline bool operator!=(const MemoryPool& rhs) const
+	{
+		return !operator==(rhs);
+	}
+
 public:
 	struct Finalizer
 	{

src/common/classes/fb_string.cpp

@@ -396,6 +396,20 @@ extern "C" {
 		shrinkBuffer();
 	}
 
+	bool AbstractString::baseMove(AbstractString&& rhs)
+	{
+		if (getPool() == rhs.getPool() && rhs.inlineBuffer != rhs.stringBuffer)
+		{
+			stringBuffer = std::exchange(rhs.stringBuffer, rhs.inlineBuffer);
+			stringLength = std::exchange(rhs.stringLength, 0);
+			bufferSize = std::exchange(rhs.bufferSize, INLINE_BUFFER_SIZE);
+			rhs.inlineBuffer[0] = '\0';
+			return true;
+		}
+
+		return false;
+	}
+
 	void AbstractString::printf(const char* format,...)
 	{
 		va_list params;

src/common/classes/fb_string.h

@@ -32,6 +32,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
+#include <utility>
 
 #include "firebird.h"
 #include "fb_types.h"
@@ -203,6 +204,27 @@ namespace Firebird
 			memcpy(stringBuffer, s, l);
 		}
 
+		AbstractString(const size_type limit, AbstractString&& rhs) :
+			max_length(static_cast<internal_size_type>(limit))
+		{
+			 // We can move only string with default pool
+			if (!baseMove(std::forward<AbstractString>(rhs)))
+			{
+				initialize(rhs.length());
+				memcpy(stringBuffer, rhs.c_str(), stringLength);
+			}
+		}
+
+		AbstractString(const size_type limit, MemoryPool& p, AbstractString&& rhs)
+			: AutoStorage(p), max_length(static_cast<internal_size_type>(limit))
+		{
+			if (!baseMove(std::forward<AbstractString>(rhs)))
+			{
+				initialize(rhs.length());
+				memcpy(stringBuffer, rhs.c_str(), stringLength);
+			}
+		}
+
 		pointer modify()
 		{
 			return stringBuffer;
@@ -223,6 +245,8 @@ namespace Firebird
 
 		void baseTrim(const TrimType whereTrim, const_pointer toTrim);
 
+		bool baseMove(AbstractString&& rhs);
+
 		size_type getMaxLength() const
 		{
 			return max_length;
@@ -676,6 +700,10 @@ namespace Firebird
 			AbstractString(Comparator::getMaxLength(), p, s, static_cast<size_type>(s ? strlen(s) : 0)) {}
 		StringBase(MemoryPool& p, const char_type* s, size_type l) :
 			AbstractString(Comparator::getMaxLength(), p, s, l) {}
+		StringBase(StringType&& rhs) :
+			AbstractString(Comparator::getMaxLength(), std::forward<AbstractString>(rhs)) {}
+		StringBase(MemoryPool& p, StringType&& rhs) :
+			AbstractString(Comparator::getMaxLength(), p, std::forward<AbstractString>(rhs)) {}
 
 		static size_type max_length()
 		{
@@ -754,6 +782,25 @@ namespace Firebird
 		{
 			return add(&c, 1);
 		}
+		StringType& operator=(StringType&& rhs)
+		{
+			// baseMove do not clear the buffer so do it in this method
+			char_type* backup = nullptr;
+			if (stringBuffer != inlineBuffer)
+				backup = stringBuffer;
+
+			if (baseMove(std::forward<AbstractString>(rhs)))
+			{
+				// The dynamic buffer has been replaced, so clear the old one
+				delete[] backup;
+			}
+			else
+			{
+				// Cannot move, do the base assignment
+				assign(rhs.c_str(), rhs.length());
+			}
+			return *this;
+		}
 
 		StringBase<StringComparator> ToString() const
 		{