BAN: Make String and StringView header only

This allows linking with libc without having to link ban

BAN/include/BAN/Errors.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <BAN/Formatter.h>
-#include <BAN/StringView.h>
 #include <BAN/Variant.h>
 
 #include <errno.h>
@@ -56,7 +55,7 @@ namespace BAN
 #endif
 
 		uint64_t get_error_code() const { return m_error_code; }
-		BAN::StringView get_message() const
+		const char* get_message() const
 		{
 #ifdef __is_kernel
 			if (m_error_code & kernel_error_mask)
@@ -64,7 +63,7 @@ namespace BAN
 #endif
 			if (auto* desc = strerrordesc_np(m_error_code))
 				return desc;
-			return "Unknown error"sv;
+			return "Unknown error";
 		}
 
 	private:

BAN/include/BAN/String.h

@@ -2,9 +2,10 @@
 
 #include <BAN/Errors.h>
 #include <BAN/Formatter.h>
-#include <BAN/ForwardList.h>
 #include <BAN/Hash.h>
 #include <BAN/Iterators.h>
+#include <BAN/New.h>
+#include <BAN/StringView.h>
 
 namespace BAN
 {
@@ -18,28 +19,125 @@ namespace BAN
 		static constexpr size_type sso_capacity = 15;
 
 	public:
-		String();
-		String(const String&);
-		String(String&&);
-		String(StringView);
-		~String();
+		String() {}
+		String(const String& other) { *this = other; }
+		String(String&& other) { *this = move(other); }
+		String(StringView other) { *this = other; }
+		~String() { clear(); }
 
 		template<typename... Args>
-		static String formatted(const char* format, const Args&... args);
+		static String formatted(const char* format, const Args&... args)
+		{
+			String result;
+			BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, args...);
+			return result;
+		}
 
-		String& operator=(const String&);
-		String& operator=(String&&);
-		String& operator=(StringView);
+		String& operator=(const String& other)
+		{
+			clear();
+			MUST(ensure_capacity(other.size()));
+			memcpy(data(), other.data(), other.size() + 1);
+			m_size = other.size();
+			return *this;
+		}
 
-		ErrorOr<void> push_back(char);
-		ErrorOr<void> insert(char, size_type);
-		ErrorOr<void> insert(StringView, size_type);
-		ErrorOr<void> append(StringView);
+		String& operator=(String&& other)
+		{
+			clear();
 
-		void pop_back();
-		void remove(size_type);
+			if (other.has_sso())
+				memcpy(data(), other.data(), other.size() + 1);
+			else
+			{
+				m_storage.general_storage = other.m_storage.general_storage;
+				m_has_sso = false;
+			}
+			m_size = other.m_size;
 
-		void clear();
+			other.m_size = 0;
+			other.m_storage.sso_storage = SSOStorage();
+			other.m_has_sso = true;
+
+			return *this;
+		}
+
+		String& operator=(StringView other)
+		{
+			clear();
+			MUST(ensure_capacity(other.size()));
+			memcpy(data(), other.data(), other.size());
+			m_size = other.size();
+			data()[m_size] = '\0';
+			return *this;
+		}
+
+		ErrorOr<void> push_back(char c)
+		{
+			TRY(ensure_capacity(m_size + 1));
+			data()[m_size] = c;
+			m_size++;
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> insert(char c, size_type index)
+		{
+			ASSERT(index <= m_size);
+			TRY(ensure_capacity(m_size + 1));
+			memmove(data() + index + 1, data() + index, m_size - index);
+			data()[index] = c;
+			m_size++;
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> insert(StringView str, size_type index)
+		{
+			ASSERT(index <= m_size);
+			TRY(ensure_capacity(m_size + str.size()));
+			memmove(data() + index + str.size(), data() + index, m_size - index);
+			memcpy(data() + index, str.data(), str.size());
+			m_size += str.size();
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> append(StringView str)
+		{
+			TRY(ensure_capacity(m_size + str.size()));
+			memcpy(data() + m_size, str.data(), str.size());
+			m_size += str.size();
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		void pop_back()
+		{
+			ASSERT(m_size > 0);
+			m_size--;
+			data()[m_size] = '\0';
+		}
+
+		void remove(size_type index)
+		{
+			ASSERT(index < m_size);
+			memcpy(data() + index, data() + index + 1, m_size - index);
+			m_size--;
+			data()[m_size] = '\0';
+		}
+
+		void clear()
+		{
+			if (!has_sso())
+			{
+				deallocator(m_storage.general_storage.data);
+				m_storage.sso_storage = SSOStorage();
+				m_has_sso = true;
+			}
+			m_size = 0;
+			data()[m_size] = '\0';
+		}
 
 		const_iterator begin() const	{ return const_iterator(data()); }
 		iterator begin()				{ return iterator(data()); }
@@ -55,27 +153,151 @@ namespace BAN
 		char operator[](size_type index) const	{ ASSERT(index < m_size); return data()[index]; }
 		char& operator[](size_type index)		{ ASSERT(index < m_size); return data()[index]; }
 
-		bool operator==(const String&) const;
-		bool operator==(StringView) const;
-		bool operator==(const char*) const;
+		bool operator==(const String& str) const
+		{
+			if (size() != str.size())
+				return false;
+			for (size_type i = 0; i < m_size; i++)
+				if (data()[i] != str.data()[i])
+					return false;
+			return true;
+		}
 
-		ErrorOr<void> resize(size_type, char = '\0');
-		ErrorOr<void> reserve(size_type);
-		ErrorOr<void> shrink_to_fit();
+		bool operator==(StringView str) const
+		{
+			if (size() != str.size())
+				return false;
+			for (size_type i = 0; i < m_size; i++)
+				if (data()[i] != str.data()[i])
+					return false;
+			return true;
+		}
+
+		bool operator==(const char* cstr) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (data()[i] != cstr[i])
+					return false;
+			if (cstr[size()] != '\0')
+				return false;
+			return true;
+		}
+
+		ErrorOr<void> resize(size_type new_size, char init_c = '\0')
+		{
+			if (m_size == new_size)
+				return {};
+
+			// expanding
+			if (m_size < new_size)
+			{
+				TRY(ensure_capacity(new_size));
+				memset(data() + m_size, init_c, new_size - m_size);
+				m_size = new_size;
+				data()[m_size] = '\0';
+				return {};
+			}
+
+			m_size = new_size;
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> reserve(size_type new_size)
+		{
+			TRY(ensure_capacity(new_size));
+			return {};
+		}
+
+		ErrorOr<void> shrink_to_fit()
+		{
+			if (has_sso())
+				return {};
+
+			if (fits_in_sso())
+			{
+				char* data = m_storage.general_storage.data;
+				m_storage.sso_storage = SSOStorage();
+				m_has_sso = true;
+				memcpy(this->data(), data, m_size + 1);
+				deallocator(data);
+				return {};
+			}
+
+			GeneralStorage& storage = m_storage.general_storage;
+			if (storage.capacity == m_size)
+				return {};
+
+			char* new_data = (char*)allocator(m_size + 1);
+			if (new_data == nullptr)
+				return Error::from_errno(ENOMEM);
+
+			memcpy(new_data, storage.data, m_size);
+			deallocator(storage.data);
+
+			storage.capacity = m_size;
+			storage.data = new_data;
+
+			return {};
+		}
 
 		StringView sv() const	{ return StringView(data(), size()); }
 
 		bool empty() const		{ return m_size == 0; }
 		size_type size() const	{ return m_size; }
-		size_type capacity() const;
 
-		char* data();
-		const char* data() const;
+		size_type capacity() const
+		{
+			if (has_sso())
+				return sso_capacity;
+			return m_storage.general_storage.capacity;
+		}
+
+		char* data()
+		{
+			if (has_sso())
+				return m_storage.sso_storage.data;
+			return m_storage.general_storage.data;
+		}
+
+		const char* data() const
+		{
+			if (has_sso())
+				return m_storage.sso_storage.data;
+			return m_storage.general_storage.data;
+		}
 
 	private:
-		ErrorOr<void> ensure_capacity(size_type);
+		ErrorOr<void> ensure_capacity(size_type new_size)
+		{
+			if (m_size >= new_size)
+				return {};
+			if (has_sso() && fits_in_sso(new_size))
+				return {};
 
-		bool has_sso() const;
+			char* new_data = (char*)allocator(new_size + 1);
+			if (new_data == nullptr)
+				return Error::from_errno(ENOMEM);
+
+			if (m_size)
+				memcpy(new_data, data(), m_size + 1);
+
+			if (has_sso())
+			{
+				m_storage.general_storage = GeneralStorage();
+				m_has_sso = false;
+			}
+			else
+				deallocator(m_storage.general_storage.data);
+
+			auto& storage = m_storage.general_storage;
+			storage.capacity = new_size;
+			storage.data = new_data;
+
+			return {};
+		}
+
+		bool has_sso() const { return m_has_sso; }
 
 		bool fits_in_sso() const { return fits_in_sso(m_size); }
 		static bool fits_in_sso(size_type size) { return size < sso_capacity; }
@@ -100,14 +322,6 @@ namespace BAN
 		size_type m_has_sso	: 1							{ true };
 	};
 
-	template<typename... Args>
-	String String::formatted(const char* format, const Args&... args)
-	{
-		String result;
-		BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, args...);
-		return result;
-	}
-
 	template<>
 	struct hash<String>
 	{

BAN/include/BAN/StringView.h

@@ -4,6 +4,7 @@
 #include <BAN/ForwardList.h>
 #include <BAN/Iterators.h>
 #include <BAN/Optional.h>
+#include <BAN/Vector.h>
 
 namespace BAN
 {
@@ -15,37 +16,171 @@ namespace BAN
 		using const_iterator = ConstIteratorSimple<char, StringView>;
 
 	public:
-		StringView();
+		StringView() {}
 		StringView(const String&);
-		StringView(const char*, size_type = -1);
+		StringView(const char* string, size_type len = -1)
+		{
+			if (len == size_type(-1))
+				len = strlen(string);
+			m_data = string;
+			m_size = len;
+		}
 
 		const_iterator begin() const { return const_iterator(m_data); }
 		const_iterator end() const { return const_iterator(m_data + m_size); }
 
-		char operator[](size_type) const;
+		char operator[](size_type index) const
+		{
+			ASSERT(index < m_size);
+			return m_data[index];
+		}
 
-		bool operator==(const String&) const;
-		bool operator==(StringView) const;
-		bool operator==(const char*) const;
+		bool operator==(StringView other) const
+		{
+			if (m_size != other.m_size)
+				return false;
+			return memcmp(m_data, other.m_data, m_size) == 0;
+		}
 
-		StringView substring(size_type, size_type = -1) const;
+		bool operator==(const char* other) const
+		{
+			if (memcmp(m_data, other, m_size))
+				return false;
+			return other[m_size] == '\0';
+		}
 
-		ErrorOr<Vector<StringView>> split(char, bool = false) const;
-		ErrorOr<Vector<StringView>> split(bool(*comp)(char), bool = false) const;
+		StringView substring(size_type index, size_type len = -1) const
+		{
+			ASSERT(index <= m_size);
+			if (len == size_type(-1))
+				len = m_size - index;
+			ASSERT(len <= m_size - index); // weird order to avoid overflow
+			StringView result;
+			result.m_data = m_data + index;
+			result.m_size = len;
+			return result;
+		}
 
-		char back() const;
-		char front() const;
+		ErrorOr<Vector<StringView>> split(char delim, bool allow_empties = false) const
+		{
+			size_type count = 0;
+			{
+				size_type start = 0;
+				for (size_type i = 0; i < m_size; i++)
+				{
+					if (m_data[i] == delim)
+					{
+						if (allow_empties || start != i)
+							count++;
+						start = i + 1;
+					}
+				}
+				if (start != m_size)
+					count++;
+			}
 
-		BAN::Optional<size_type> find(char) const;
-		BAN::Optional<size_type> find(bool(*comp)(char)) const;
+			Vector<StringView> result;
+			TRY(result.reserve(count));
 
-		bool contains(char) const;
-		size_type count(char) const;
+			size_type start = 0;
+			for (size_type i = 0; i < m_size; i++)
+			{
+				if (m_data[i] == delim)
+				{
+					if (allow_empties || start != i)
+						TRY(result.push_back(this->substring(start, i - start)));
+					start = i + 1;
+				}
+			}
+			if (start < m_size || (start == m_size && allow_empties))
+				TRY(result.push_back(this->substring(start)));
+			return result;
+		}
 
-		bool empty() const;
-		size_type size() const;
+		ErrorOr<Vector<StringView>> split(bool(*comp)(char), bool allow_empties = false) const
+		{
+			size_type count = 0;
+			{
+				size_type start = 0;
+				for (size_type i = 0; i < m_size; i++)
+				{
+					if (comp(m_data[i]))
+					{
+						if (allow_empties || start != i)
+							count++;
+						start = i + 1;
+					}
+				}
+				if (start != m_size)
+					count++;
+			}
 
-		const char* data() const;
+			Vector<StringView> result;
+			TRY(result.reserve(count));
+
+			size_type start = 0;
+			for (size_type i = 0; i < m_size; i++)
+			{
+				if (comp(m_data[i]))
+				{
+					if (allow_empties || start != i)
+						TRY(result.push_back(this->substring(start, i - start)));
+					start = i + 1;
+				}
+			}
+			if (start < m_size || (start == m_size && allow_empties))
+				TRY(result.push_back(this->substring(start)));
+			return result;
+		}
+
+		char back() const
+		{
+			ASSERT(m_size > 0);
+			return m_data[m_size - 1];
+		}
+
+		char front() const
+		{
+			ASSERT(m_size > 0);
+			return m_data[0];
+		}
+
+		BAN::Optional<size_type> find(char ch) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] == ch)
+					return i;
+			return {};
+		}
+
+		BAN::Optional<size_type> find(bool(*comp)(char)) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (comp(m_data[i]))
+					return i;
+			return {};
+		}
+
+		bool contains(char ch) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] == ch)
+					return true;
+			return false;
+		}
+
+		size_type count(char ch) const
+		{
+			size_type result = 0;
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] == ch)
+					result++;
+			return result;
+		}
+
+		bool empty() const { return m_size == 0; }
+		size_type size() const { return m_size; }
+		const char* data() const { return m_data; }
 
 	private:
 		const char*	m_data = nullptr;