DBString - use DBArrayBase allocators

Author: mateofio

CMakeLists.txt

@@ -36,7 +36,6 @@ add_library(lcf)
 set(LCF_SOURCES
 	src/data.cpp
 	src/dbarray.cpp
-	src/dbstring.cpp
 	src/encoder.cpp
 	src/ini.cpp
 	src/inireader.cpp

Makefile.am

@@ -44,7 +44,6 @@ liblcf_la_LDFLAGS = \
 liblcf_la_SOURCES = \
 	src/data.cpp \
 	src/dbarray.cpp \
-	src/dbstring.cpp \
 	src/encoder.cpp \
 	src/ini.cpp \
 	src/inireader.cpp \

src/dbarray.cpp

@@ -1,4 +1,5 @@
 #include "lcf/dbarray.h"
+#include "lcf/dbstring.h"
 #include <cassert>
 #include <cstddef>
 
@@ -11,6 +12,7 @@
 namespace lcf {
 
 constexpr DBArrayBase::size_type DBArrayBase::_empty_buf;
+constexpr DBString::size_type DBString::npos;
 
 static ptrdiff_t HeaderSize(size_t align) {
 	return std::max(sizeof(DBArrayBase::size_type), align);
@@ -60,4 +62,29 @@ void DBArrayBase::free(void* p, size_type align) noexcept {
 	}
 }
 
+char* DBString::construct_z(const char* s, size_t len) {
+	auto* p = alloc(len);
+	if (len) {
+		std::memcpy(p, s, len + 1);
+	}
+	return p;
+}
+
+char* DBString::construct_sv(const char* s, size_t len) {
+	auto* p = alloc(len);
+	if (len) {
+		std::memcpy(p, s, len);
+		p[len] = '\0';
+	}
+	return p;
+}
+
+DBString& DBString::operator=(const DBString& o) {
+	if (this != &o) {
+		destroy();
+		_storage = construct_z(o.data(), o.size());
+	}
+	return *this;
+}
+
 } // namespace lcf

src/dbstring.cpp

@@ -19,13 +19,14 @@
 #include <ostream>
 
 #include "lcf/string_view.h"
+#include "lcf/dbarray.h"
 
 namespace lcf {
 
 // A custom string class optimized for database storage.
 // This string type is good for storing and retrieving values.
 // It is not good for string manipulation like insertion or concatenation.
-class DBString {
+class DBString : public DBArrayBase {
 	public:
 		using value_type = char;
 		using size_type = uint32_t;
@@ -41,14 +42,14 @@ class DBString {
 		static constexpr size_type npos = size_type(-1);
 
 		constexpr DBString() = default;
-		explicit DBString(StringView s);
-		explicit DBString(const std::string& s) : DBString(StringView(s)) {}
+		explicit DBString(StringView s) : _storage(construct_sv(s.data(), s.size())) {}
+		explicit DBString(const std::string& s) : _storage(construct_z(s.c_str(), s.size())) {}
 
 		// Explicit construct for general const char*
 		explicit DBString(const char* s) : DBString(StringView(s)) {}
 		// Implicit constructor to capture string literals
 		template <size_t N>
-			DBString(const char(&literal)[N]) : DBString(StringView(literal)) {}
+			DBString(const char(&literal)[N]) : _storage(construct_z(literal, N - 1)) {}
 		DBString(const char* s, size_t len) : DBString(StringView(s, len)) {}
 
 		DBString(const DBString& o) : DBString(StringView(o)) {}
@@ -61,7 +62,7 @@ class DBString {
 			std::swap(_storage, o._storage);
 		}
 
-		~DBString() { _reset(); }
+		~DBString() { destroy(); }
 
 		explicit operator std::string() const { return std::string(data(), size()); }
 		operator StringView() const { return StringView(data(), size()); }
@@ -75,8 +76,8 @@ class DBString {
 		char& back() { return (*this)[size()-1]; }
 		char back() const { return (*this)[size()-1]; }
 
-		char* data() { return _storage; }
-		const char* data() const { return _storage; }
+		char* data() { return static_cast<char*>(_storage); }
+		const char* data() const { return static_cast<const char*>(_storage); }
 
 		const char* c_str() const { return data(); }
 
@@ -99,16 +100,20 @@ class DBString {
 		const_reverse_iterator crend() const { return rend(); }
 
 		bool empty() const { return size() == 0; }
-		size_type size() const;
+		size_type size() const { return *this->get_size_ptr(_storage); }
 
-		static constexpr char* empty_str() {
-			return const_cast<char*>(_empty_str + sizeof(size_type));
-		}
 	private:
-		void _reset() noexcept;
+		char* alloc(size_t count) {
+			return reinterpret_cast<char*>(DBArrayBase::alloc(count + 1, count, 1));
+		}
+		void free(void* p) {
+			DBArrayBase::free(p, 1);
+		}
+		void destroy() noexcept;
+		char* construct_z(const char* s, size_t len);
+		char* construct_sv(const char* s, size_t len);
 	private:
-		alignas(size_type) static constexpr char _empty_str[sizeof(size_type)] = {};
-		char* _storage = empty_str();
+		void* _storage = this->empty_buf();
 };
 
 // This should be used over the conversion operator, so we can track all dbstr -> str instances
@@ -151,17 +156,17 @@ namespace lcf {
 
 inline DBString& DBString::operator=(DBString&& o) noexcept {
 	if (this != &o) {
-		if (!empty()) {
-			_reset();
-		}
-		_storage = o._storage;
-		o._storage = empty_str();
+		destroy();
+		swap(o);
 	}
 	return *this;
 }
 
-inline DBString::size_type DBString::size() const {
-	return *(reinterpret_cast<const size_type*>(_storage) - 1);
+inline void DBString::destroy() noexcept {
+	if (_storage != this->empty_buf()) {
+		free(_storage);
+		_storage = this->empty_buf();
+	}
 }
 
 } // namespace lcf