Replace all ReferenceString& with std::string_view, various cleanup

src/common/Command.cpp

@@ -19,42 +19,23 @@
 #include <cstring>
 #include "jessilib/unicode.hpp"
 #include "Command.h"
-#include "String.hpp"
-
-struct Jupiter::Command::Data { // TODO: remove pimpl
-	std::vector<std::string> triggers;
-};
-
-Jupiter::Command::Command() {
-	m_data = new Data();
-}
-
-Jupiter::Command::Command(const Command &command) {
-	m_data = new Data();
-	//for (size_t i = 0; i != m_data->triggers.size(); i++) // triggers.size() would always be 0? this code does nothing?
-	//	m_data->triggers.add(new Jupiter::StringS(*command.m_data->triggers.get(i)));
-}
-
-Jupiter::Command::~Command() {
-	delete m_data;
-}
 
 // Command Functions
 
 void Jupiter::Command::addTrigger(std::string_view trigger) {
-	m_data->triggers.emplace_back(trigger);
+	m_triggers.emplace_back(trigger);
 }
 
 std::string_view Jupiter::Command::getTrigger(size_t index) const {
-	return m_data->triggers[index];
+	return m_triggers[index];
 }
 
 size_t Jupiter::Command::getTriggerCount() const {
-	return m_data->triggers.size();
+	return m_triggers.size();
 }
 
 bool Jupiter::Command::matches(std::string_view in_trigger) const {
-	for (const auto& trigger : m_data->triggers) {
+	for (const auto& trigger : m_triggers) {
 		if (jessilib::equalsi(trigger, in_trigger)) {
 			return true;
 		}

src/common/Database.cpp

@@ -36,7 +36,7 @@ void Jupiter::Database::create_header(FILE *)
 {
 }
 
-bool Jupiter::Database::process_file(const Jupiter::ReadableString &file)
+bool Jupiter::Database::process_file(std::string_view file)
 {
 	Jupiter::Database::data_->file_name = static_cast<std::string>(file);
 	return Jupiter::Database::Data::process_file(this);
@@ -125,17 +125,11 @@ bool Jupiter::Database::append(Jupiter::DataBuffer &data)
 	return Jupiter::Database::append(Jupiter::Database::data_->file_name, data);
 }
 
-bool Jupiter::Database::append(Jupiter::ReadableString &file, Jupiter::DataBuffer &data)
-{
-	char *str = new char[file.size() + 1];
-	memcpy(str, file.data(), file.size() * sizeof(char));
-	str[file.size()] = '\0';
-	bool r = Jupiter::Database::append(str, data);
-	delete[] str;
-	return r;
+bool Jupiter::Database::append(std::string_view file, Jupiter::DataBuffer &data) {
+	return append(static_cast<std::string>(file), data);
 }
 
-bool Jupiter::Database::append(std::string &file, Jupiter::DataBuffer &data)
+bool Jupiter::Database::append(const std::string& file, Jupiter::DataBuffer &data)
 {
 	return Jupiter::Database::append(file.c_str(), data);
 }
@@ -158,7 +152,7 @@ bool Jupiter::Database::append(FILE *file, Jupiter::DataBuffer &data)
 	return true;
 }
 
-bool Jupiter::Database::create_database(const Jupiter::ReadableString &file, const Jupiter::DataBuffer *header)
+bool Jupiter::Database::create_database(std::string_view file, const Jupiter::DataBuffer *header)
 {
 	char *str = new char[file.size() + 1];
 	memcpy(str, file.data(), file.size() * sizeof(char));

src/common/GenericCommand.cpp

@@ -53,7 +53,7 @@ bool Jupiter::GenericCommand::isNamespace() const {
 	return false;
 }
 
-void Jupiter::GenericCommand::setNamespace(const Jupiter::ReadableString &in_namespace) {
+void Jupiter::GenericCommand::setNamespace(std::string_view in_namespace) {
 	if (Jupiter::GenericCommand::m_parent == nullptr) {
 		return; // We have no parent to start from
 	}
@@ -80,7 +80,7 @@ Jupiter::GenericCommandNamespace *Jupiter::GenericCommand::getNamespace() const
 
 /** GenericCommand::ResponseLine */
 
-Jupiter::GenericCommand::ResponseLine::ResponseLine(const Jupiter::ReadableString &in_response, GenericCommand::DisplayType in_type)
+Jupiter::GenericCommand::ResponseLine::ResponseLine(std::string_view in_response, GenericCommand::DisplayType in_type)
 	: response{ in_response },
 	type{ in_type } {
 }
@@ -90,7 +90,7 @@ Jupiter::GenericCommand::ResponseLine::ResponseLine(std::string in_response, Gen
 	type{ in_type } {
 }
 
-Jupiter::GenericCommand::ResponseLine* Jupiter::GenericCommand::ResponseLine::set(const Jupiter::ReadableString &in_response, GenericCommand::DisplayType in_type) {
+Jupiter::GenericCommand::ResponseLine* Jupiter::GenericCommand::ResponseLine::set(std::string_view in_response, GenericCommand::DisplayType in_type) {
 	response = in_response;
 	type = in_type;
 	return this;
@@ -101,7 +101,7 @@ Jupiter::GenericCommand::ResponseLine* Jupiter::GenericCommand::ResponseLine::se
 Jupiter::GenericCommandNamespace::~GenericCommandNamespace() {
 }
 
-Jupiter::GenericCommand::ResponseLine* Jupiter::GenericCommandNamespace::trigger(const Jupiter::ReadableString &in_input) {
+Jupiter::GenericCommand::ResponseLine* Jupiter::GenericCommandNamespace::trigger(std::string_view in_input) {
 	GenericCommand* command;
 	Jupiter::ReferenceString input(in_input);
 	auto split_input = jessilib::word_split_once_view(input, GENERIC_COMMAND_WORD_DELIMITER_SV);
@@ -112,13 +112,13 @@ Jupiter::GenericCommand::ResponseLine* Jupiter::GenericCommandNamespace::trigger
 
 	command = Jupiter::GenericCommandNamespace::getCommand(split_input.first);
 	if (command != nullptr) {
-		return command->trigger(Jupiter::ReferenceString{split_input.second});
+		return command->trigger(split_input.second);
 	}
 
 	return new Jupiter::GenericCommand::ResponseLine(""_jrs, Jupiter::GenericCommand::DisplayType::PrivateError);
 }
 
-const Jupiter::ReadableString &Jupiter::GenericCommandNamespace::getHelp(const Jupiter::ReadableString &parameters) {
+std::string_view Jupiter::GenericCommandNamespace::getHelp(std::string_view parameters) {
 	static Jupiter::ReferenceString not_found = "Error: Command not found"_jrs;
 	Jupiter::ReferenceString input(parameters);
 
@@ -136,7 +136,7 @@ const Jupiter::ReadableString &Jupiter::GenericCommandNamespace::getHelp(const J
 	// Search for command
 	command = Jupiter::GenericCommandNamespace::getCommand(input_split.first);
 	if (command != nullptr) {
-		return command->getHelp(Jupiter::ReferenceString{input_split.second});
+		return command->getHelp(input_split.second);
 	}
 
 	// Command not found

src/common/HTTP_Server.cpp

@@ -452,7 +452,7 @@ int Jupiter::HTTP::Server::Data::process_request(HTTPSession &session) {
 				{
 					// 200 (success)
 					// TODO: remove referencestring warpper
-					std::string* content_result = content->execute(Jupiter::ReferenceString{query_string});
+					std::string* content_result = content->execute(query_string);
 
 					switch (session.version)
 					{
@@ -481,21 +481,22 @@ int Jupiter::HTTP::Server::Data::process_request(HTTPSession &session) {
 						result += "Connection: close"_jrs ENDL;
 
 					result += "Content-Type: "_jrs;
-					if (content->type == nullptr)
+					if (content->type.empty()) {
 						result += Jupiter::HTTP::Content::Type::Text::PLAIN;
-					else
-						result += *content->type;
-					if (content->charset != nullptr)
-					{
+					}
+					else {
+						result += content->type;
+					}
+
+					if (!content->charset.empty()) {
 						result += "; charset="_jrs;
-						result += *content->charset;
+						result += content->charset;
 					}
 					result += ENDL;
 
-					if (content->language != nullptr)
-					{
+					if (!content->language.empty()) {
 						result += "Content-Language: "_jrs;
-						result += *content->language;
+						result += content->language;
 						result += ENDL;
 					}
 
@@ -827,5 +828,5 @@ int Jupiter::HTTP::Server::think() {
 	return 0;
 }
 
-const Jupiter::ReadableString &Jupiter::HTTP::Server::global_namespace = ""_jrs;
-const Jupiter::ReadableString &Jupiter::HTTP::Server::server_string = "Jupiter"_jrs;
+std::string_view Jupiter::HTTP::Server::global_namespace = ""_jrs;
+std::string_view Jupiter::HTTP::Server::server_string = "Jupiter"_jrs;

src/common/IRC_Client.cpp

@@ -215,7 +215,7 @@ std::string_view Jupiter::IRC::Client::getRealname() const {
 	return m_realname;
 }
 
-const Jupiter::ReadableString &Jupiter::IRC::Client::getServerName() const {
+std::string_view Jupiter::IRC::Client::getServerName() const {
 	return m_server_name;
 }
 
@@ -270,7 +270,7 @@ int Jupiter::IRC::Client::getAccessLevel(const Channel &in_channel, std::string_
 }
 
 int Jupiter::IRC::Client::getAccessLevel(std::string_view in_channel, std::string_view in_nickname) const {
-	auto channel = m_channels.find(Jupiter::ReferenceString{in_channel});
+	auto channel = m_channels.find(in_channel);
 
 	if (channel != m_channels.end())
 		return this->getAccessLevel(channel->second, in_nickname);
@@ -278,7 +278,7 @@ int Jupiter::IRC::Client::getAccessLevel(std::string_view in_channel, std::strin
 	return 0;
 }
 
-void Jupiter::IRC::Client::send(const Jupiter::ReadableString &rawMessage) {
+void Jupiter::IRC::Client::send(std::string_view rawMessage) {
 	Jupiter::StringS out = rawMessage;
 	out += ENDL;
 
@@ -294,7 +294,7 @@ size_t Jupiter::IRC::Client::getUserCount() const {
 }
 
 std::shared_ptr<Jupiter::IRC::Client::User> Jupiter::IRC::Client::getUser(std::string_view in_nickname) const {
-	auto user = m_users.find(Jupiter::ReferenceString{in_nickname});
+	auto user = m_users.find(in_nickname);
 	if (user != m_users.end()) {
 		return user->second;
 	}
@@ -368,7 +368,7 @@ size_t Jupiter::IRC::Client::messageChannels(int type, std::string_view message)
 	return m_channels.size();
 }
 
-size_t Jupiter::IRC::Client::messageChannels(const Jupiter::ReadableString &message)
+size_t Jupiter::IRC::Client::messageChannels(std::string_view message)
 {
 	for (auto& channel : m_channels) {
 		sendMessage(channel.second.getName(), message);
@@ -926,7 +926,7 @@ int Jupiter::IRC::Client::process_line(std::string_view in_line) {
 												}
 
 												if (user->getChannelCount() == 0) {
-													m_users.erase(Jupiter::ReferenceString{kicked_nickname});
+													m_users.erase(kicked_nickname);
 												}
 											}
 										}
@@ -1164,7 +1164,7 @@ void Jupiter::IRC::Client::disconnect(bool stayDead)
 	}
 }
 
-void Jupiter::IRC::Client::disconnect(const Jupiter::ReadableString &message, bool stayDead)
+void Jupiter::IRC::Client::disconnect(std::string_view message, bool stayDead)
 {
 	m_socket->send(Jupiter::StringS::Format("QUIT :%.*s" ENDL, message.size(), message.data()));
 	Jupiter::IRC::Client::disconnect(stayDead);
@@ -1253,7 +1253,7 @@ int Jupiter::IRC::Client::think()
 	return handle_error(tmp);
 }
 
-std::string_view Jupiter::IRC::Client::readConfigValue(const Jupiter::ReadableString &key, std::string_view defaultValue) const {
+std::string_view Jupiter::IRC::Client::readConfigValue(std::string_view key, std::string_view defaultValue) const {
 	if (m_primary_section != nullptr) {
 		std::string_view val = m_primary_section->get(key);
 		if (!val.empty()) {
@@ -1268,7 +1268,7 @@ std::string_view Jupiter::IRC::Client::readConfigValue(const Jupiter::ReadableSt
 	return defaultValue;
 }
 
-bool Jupiter::IRC::Client::readConfigBool(const Jupiter::ReadableString &key, bool defaultValue) const {
+bool Jupiter::IRC::Client::readConfigBool(std::string_view key, bool defaultValue) const {
 	if (m_primary_section != nullptr) {
 		std::string_view val = m_primary_section->get(key);
 
@@ -1284,7 +1284,7 @@ bool Jupiter::IRC::Client::readConfigBool(const Jupiter::ReadableString &key, bo
 	return defaultValue;
 }
 
-int Jupiter::IRC::Client::readConfigInt(const Jupiter::ReadableString &key, int defaultValue) const {
+int Jupiter::IRC::Client::readConfigInt(std::string_view key, int defaultValue) const {
 	if (m_primary_section != nullptr) {
 		std::string_view val = m_primary_section->get(key);
 
@@ -1300,7 +1300,7 @@ int Jupiter::IRC::Client::readConfigInt(const Jupiter::ReadableString &key, int
 	return defaultValue;
 }
 
-long Jupiter::IRC::Client::readConfigLong(const Jupiter::ReadableString &key, long defaultValue) const {
+long Jupiter::IRC::Client::readConfigLong(std::string_view key, long defaultValue) const {
 	if (m_primary_section != nullptr) {
 		std::string_view val = m_primary_section->get(key);
 
@@ -1315,7 +1315,7 @@ long Jupiter::IRC::Client::readConfigLong(const Jupiter::ReadableString &key, lo
 	return defaultValue;
 }
 
-double Jupiter::IRC::Client::readConfigDouble(const Jupiter::ReadableString &key, double defaultValue) const {
+double Jupiter::IRC::Client::readConfigDouble(std::string_view key, double defaultValue) const {
 	if (m_primary_section != nullptr) {
 		std::string_view val = m_primary_section->get(key);
 
@@ -1331,7 +1331,7 @@ double Jupiter::IRC::Client::readConfigDouble(const Jupiter::ReadableString &key
 	return defaultValue;
 }
 
-void Jupiter::IRC::Client::writeToLogs(const Jupiter::ReadableString &message) {
+void Jupiter::IRC::Client::writeToLogs(std::string_view message) {
 	if (m_log_file != nullptr) {
 		fwrite(message.data(), sizeof(char), message.size(), m_log_file);
 		fputs("\r\n", m_log_file);
@@ -1344,10 +1344,10 @@ void Jupiter::IRC::Client::writeToLogs(const Jupiter::ReadableString &message) {
 */
 
 void Jupiter::IRC::Client::delChannel(std::string_view in_channel) {
-	m_channels.erase(Jupiter::ReferenceString{in_channel});
+	m_channels.erase(in_channel);
 }
 
-std::shared_ptr<Jupiter::IRC::Client::User> Jupiter::IRC::Client::findUser(const Jupiter::ReadableString &in_nickname) const {
+std::shared_ptr<Jupiter::IRC::Client::User> Jupiter::IRC::Client::findUser(std::string_view in_nickname) const {
 	return getUser(in_nickname);
 }
 
@@ -1452,7 +1452,7 @@ size_t Jupiter::IRC::Client::User::getChannelCount() const {
 * Channel Implementation
 */
 
-Jupiter::IRC::Client::Channel::Channel(const Jupiter::ReadableString &in_name, Jupiter::IRC::Client *in_parent) {
+Jupiter::IRC::Client::Channel::Channel(std::string_view in_name, Jupiter::IRC::Client *in_parent) {
 	auto to_lower = [&in_name]() {
 		Jupiter::String result(in_name.size());
 		const char *itr = in_name.data();
@@ -1490,7 +1490,7 @@ std::shared_ptr<Jupiter::IRC::Client::Channel::User> Jupiter::IRC::Client::Chann
 
 	++user->m_channel_count;
 
-	m_users[Jupiter::ReferenceString{channel_user->getNickname()}] = channel_user;
+	m_users[channel_user->getNickname()] = channel_user;
 	return channel_user;
 }
 
@@ -1501,12 +1501,12 @@ std::shared_ptr<Jupiter::IRC::Client::Channel::User> Jupiter::IRC::Client::Chann
 
 	++user->m_channel_count;
 
-	m_users[Jupiter::ReferenceString{channel_user->getNickname()}] = channel_user;
+	m_users[channel_user->getNickname()] = channel_user;
 	return channel_user;
 }
 
 void Jupiter::IRC::Client::Channel::delUser(std::string_view in_nickname) {
-	m_users.erase(Jupiter::ReferenceString{in_nickname});
+	m_users.erase(in_nickname);
 }
 
 void Jupiter::IRC::Client::Channel::addUserPrefix(std::string_view in_nickname, char prefix) {
@@ -1527,12 +1527,12 @@ void Jupiter::IRC::Client::Channel::delUserPrefix(std::string_view in_nickname,
 	}
 }
 
-const Jupiter::ReadableString &Jupiter::IRC::Client::Channel::getName() const {
+std::string_view Jupiter::IRC::Client::Channel::getName() const {
 	return m_name;
 }
 
 std::shared_ptr<Jupiter::IRC::Client::Channel::User> Jupiter::IRC::Client::Channel::getUser(std::string_view in_nickname) const {
-	auto user = m_users.find(Jupiter::ReferenceString{in_nickname});
+	auto user = m_users.find(in_nickname);
 	if (user != m_users.end()) {
 		return user->second;
 	}
@@ -1591,7 +1591,7 @@ Jupiter::IRC::Client::User *Jupiter::IRC::Client::Channel::User::getUser() const
 	return m_user.get();
 }
 
-const Jupiter::ReadableString &Jupiter::IRC::Client::Channel::User::getPrefixes() const {
+std::string_view Jupiter::IRC::Client::Channel::User::getPrefixes() const {
 	return m_prefixes;
 }
 

src/common/Plugin.cpp

@@ -73,7 +73,7 @@ const char module_file_extension[]{ ".dll" };
 const char module_file_extension[]{ ".so" };
 #endif // _WIN32
 
-const Jupiter::ReferenceString config_file_extension = ".ini"_jrs;
+constexpr std::string_view config_file_extension = ".ini"sv;
 
 std::string plugins_directory = "Plugins"s + directory_character;
 std::string plugin_configs_directory = "Configs"s + directory_character;
@@ -102,7 +102,7 @@ bool Jupiter::Plugin::shouldRemove() const {
 	return _shouldRemove;
 }
 
-const Jupiter::ReadableString &Jupiter::Plugin::getName() const {
+std::string_view Jupiter::Plugin::getName() const {
 	return name;
 }
 
@@ -119,7 +119,7 @@ void Jupiter::Plugin::OnPostInitialize() {
 
 // Static Functions
 
-void Jupiter::Plugin::setDirectory(const Jupiter::ReadableString &dir) {
+void Jupiter::Plugin::setDirectory(std::string_view dir) {
 	plugins_directory = dir;
 	if (!plugins_directory.empty() && plugins_directory.back() != directory_character) {
 		plugins_directory += directory_character;
@@ -130,7 +130,7 @@ const std::string& Jupiter::Plugin::getDirectory() {
 	return plugins_directory;
 }
 
-void Jupiter::Plugin::setConfigDirectory(const Jupiter::ReadableString &dir) {
+void Jupiter::Plugin::setConfigDirectory(std::string_view dir) {
 	plugin_configs_directory = dir;
 	if (!plugin_configs_directory.empty() && plugin_configs_directory.back() != directory_character) {
 		plugin_configs_directory += directory_character;
@@ -180,7 +180,7 @@ Jupiter::Plugin *Jupiter::Plugin::load(const std::string_view& pluginName) {
 		}
 
 		// Initialize the plugin
-		weak_plugin->name = Jupiter::ReferenceString{pluginName};
+		weak_plugin->name = pluginName;
 		std::string config_path = plugin_configs_directory;
 		config_path += pluginName;
 		config_path += config_file_extension;

src/common/Socket.cpp

@@ -476,12 +476,12 @@ size_t Jupiter::Socket::getBufferSize() const {
 	return Jupiter::Socket::data_->buffer.capacity();
 }
 
-const Jupiter::ReadableString &Jupiter::Socket::setBufferSize(size_t size) {
+std::string_view Jupiter::Socket::setBufferSize(size_t size) {
 	Jupiter::Socket::data_->buffer.setBufferSize(size);
 	return Jupiter::Socket::data_->buffer;
 }
 
-const Jupiter::ReadableString &Jupiter::Socket::getData() {
+std::string_view Jupiter::Socket::getData() {
 	if (this->recv() <= 0)
 		Jupiter::Socket::data_->buffer.erase();
 	return Jupiter::Socket::data_->buffer;

src/include/Jupiter/Command.h

@@ -24,8 +24,16 @@
  * @brief Provides an extendable command system.
  */
 
+#include <vector>
+#include <string>
+#include <string_view>
 #include "Jupiter.h"
-#include "Reference_String.h"
+
+/** DLL Linkage Nagging */
+#if defined _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
 
 namespace Jupiter
 {
@@ -73,29 +81,33 @@ namespace Jupiter
 		* @param parameters Optional string containing any data to be passed to the help command.
 		* @return Brief description of command and syntax.
 		*/
-		virtual const Jupiter::ReadableString &getHelp(const Jupiter::ReadableString &parameters = Jupiter::ReferenceString{}) = 0;
+		virtual std::string_view getHelp(std::string_view parameters = {}) = 0;
 
 		/**
 		* @brief Default constructor for command class.
 		*/
-		Command();
+		Command() = default;
 
 		/**
 		* @brief Copy constructor for command class.
 		*/
-		Command(const Command &command);
+		Command(const Command &command) = default;
 
 		/**
 		* @brief destructor for command class.
 		*/
-		virtual ~Command();
+		virtual ~Command() = default;
 
 		/** Private members */
 	private:
-		struct Data;
-		Data *m_data;
+		std::vector<std::string> m_triggers;
 	};
 
 }
 
+/** Re-enable warnings */
+#if defined _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
 #endif // _COMMAND_H_HEADER

src/include/Jupiter/Database.h

@@ -66,7 +66,7 @@ namespace Jupiter
 		* @param file File being processed
 		* @return True on success, false otherwise
 		*/
-		bool process_file(const Jupiter::ReadableString &file);
+		bool process_file(std::string_view file);
 		bool process_file(const std::string &file);
 		bool process_file(const char *file);
 		bool process_file(FILE *file);
@@ -99,8 +99,8 @@ namespace Jupiter
 		* @param data DataBuffer to append
 		* @return True on success, false otherwise.
 		*/
-		static bool append(Jupiter::ReadableString &file, Jupiter::DataBuffer &data);
-		static bool append(std::string &file, Jupiter::DataBuffer &data);
+		static bool append(std::string_view file, Jupiter::DataBuffer &data);
+		static bool append(const std::string& file, Jupiter::DataBuffer &data);
 		static bool append(const char *file, Jupiter::DataBuffer &data);
 		static bool append(FILE *file, Jupiter::DataBuffer &data);
 
@@ -111,7 +111,7 @@ namespace Jupiter
 		* @param flie Name of the Database to generate
 		* @param header DataBuffer containing the header to write to the file
 		*/
-		static bool create_database(const Jupiter::ReadableString &file, const Jupiter::DataBuffer *header = nullptr);
+		static bool create_database(std::string_view file, const Jupiter::DataBuffer *header = nullptr);
 		static bool create_database(const std::string &file, const Jupiter::DataBuffer *header = nullptr);
 		static bool create_database(const char *file, const Jupiter::DataBuffer *header = nullptr);
 

src/include/Jupiter/GenericCommand.h

@@ -68,9 +68,9 @@ namespace Jupiter
 			* @param in_type Value to set type to.
 			* @return This.
 			*/
-			ResponseLine *set(const Jupiter::ReadableString &response, GenericCommand::DisplayType type);
+			ResponseLine *set(std::string_view response, GenericCommand::DisplayType type);
 			ResponseLine() = default;
-			ResponseLine(const Jupiter::ReadableString &response, GenericCommand::DisplayType type);
+			ResponseLine(std::string_view response, GenericCommand::DisplayType type);
 			ResponseLine(std::string response, GenericCommand::DisplayType type);
 		};
 
@@ -79,7 +79,7 @@ namespace Jupiter
 		*
 		* @param input Parameters passed to the command by the user.
 		*/
-		virtual ResponseLine *trigger(const Jupiter::ReadableString &input) = 0;
+		virtual ResponseLine *trigger(std::string_view input) = 0;
 
 		/**
 		* @brief Checks if this command is a namespace
@@ -94,7 +94,7 @@ namespace Jupiter
 		*
 		* @param in_namespace Name of the namespace to move the command into
 		*/
-		void setNamespace(const Jupiter::ReadableString &in_namespace);
+		void setNamespace(std::string_view in_namespace);
 
 		/**
 		* @brief Places this command in a namespace
@@ -130,8 +130,8 @@ namespace Jupiter
 	class JUPITER_API GenericCommandNamespace : public Jupiter::GenericCommand
 	{
 	public: // Jupiter::Command
-		ResponseLine *trigger(const Jupiter::ReadableString &input) override;
-		const Jupiter::ReadableString &getHelp(const Jupiter::ReadableString &parameters) override;
+		ResponseLine *trigger(std::string_view input) override;
+		std::string_view getHelp(std::string_view parameters) override;
 
 	public: // Jupiter::GenericCommand
 		bool isNamespace() const override;
@@ -170,8 +170,8 @@ namespace Jupiter
 #define BASE_GENERIC_COMMAND(CLASS) \
 	public: \
 	CLASS(); \
-	Jupiter::GenericCommand::ResponseLine *trigger(const Jupiter::ReadableString &parameters) override; \
-	const Jupiter::ReadableString &getHelp(const Jupiter::ReadableString &parameters) override; \
+	Jupiter::GenericCommand::ResponseLine *trigger(std::string_view parameters) override; \
+	std::string_view getHelp(std::string_view parameters) override; \
 	static CLASS &instance;
 
 /** Expands to become the entire declaration for a generic command. In most cases, this will be sufficient. */

src/include/Jupiter/HTTP_QueryString.h

@@ -39,7 +39,7 @@ namespace Jupiter
 		{
 		public:
 			QueryString() = delete;
-			inline QueryString(const Jupiter::ReadableString &query_string) : QueryString(query_string.data(), query_string.size()) {}
+			inline QueryString(std::string_view query_string) : QueryString(query_string.data(), query_string.size()) {}
 			inline QueryString(const char *ptr, size_t str_size);
 		};
 
@@ -212,7 +212,7 @@ inline Jupiter::HTTP::HTMLFormResponse::HTMLFormResponse(const char *ptr, size_t
 		else if (*ptr == '&') // End of key/value, start of key
 		{
 			if (!key.empty()) { // A key was already set; end of value
-				Jupiter::HTTP::HTMLFormResponse::table[key] = Jupiter::ReferenceString(token_start, buf - token_start);
+				Jupiter::HTTP::HTMLFormResponse::table[key] = std::string_view(token_start, buf - token_start);
 			}
 
 			key = std::string_view{};
@@ -239,13 +239,13 @@ inline Jupiter::HTTP::HTMLFormResponse::HTMLFormResponse(const char *ptr, size_t
 	{
 		key = std::string_view(token_start, ++buf - token_start);
 		*buf = *++ptr;
-		Jupiter::HTTP::HTMLFormResponse::table[key] = Jupiter::ReferenceString(ptr, 1);
+		Jupiter::HTTP::HTMLFormResponse::table[key] = std::string_view(ptr, 1);
 	}
 	else
 		*++buf = *++ptr;
 
 	if (!key.empty()) // A key was already set; end of value
-		Jupiter::HTTP::HTMLFormResponse::table[key] = Jupiter::ReferenceString(token_start, buf - token_start + 1);
+		Jupiter::HTTP::HTMLFormResponse::table[key] = std::string_view(token_start, buf - token_start + 1);
 
 	Jupiter::StringType::length = buf + 1 - str;
 }

src/include/Jupiter/HTTP_Server.h

@@ -46,8 +46,8 @@ namespace Jupiter
 
 		public: // Server
 			typedef std::string* HTTPFunction(std::string_view query_string);
-			static const Jupiter::ReadableString &global_namespace;
-			static const Jupiter::ReadableString &server_string;
+			static std::string_view global_namespace;
+			static std::string_view server_string;
 
 			struct JUPITER_API Content
 			{
@@ -55,9 +55,9 @@ namespace Jupiter
 				Jupiter::HTTP::Server::HTTPFunction *function; // function to generate content data
 				std::string name; // name of the content
 				unsigned int name_checksum; // name.calcChecksum()
-				const Jupiter::ReadableString *language = nullptr; // Pointer to a constant (or otherwise managed) string
-				const Jupiter::ReadableString *type = nullptr; // Pointer to a constant (or otherwise managed) string
-				const Jupiter::ReadableString *charset = nullptr; // Pointer to a constant (or otherwise managed) string
+				std::string_view language; // Pointer to a constant (or otherwise managed) string
+				std::string_view type; // Pointer to a constant (or otherwise managed) string
+				std::string_view charset; // Pointer to a constant (or otherwise managed) string
 
 				virtual std::string* execute(std::string_view query_string);
 

src/include/Jupiter/IRC_Client.h

@@ -277,7 +277,7 @@ namespace Jupiter
 					*
 					* @return String containing the user's channel prefixes.
 					*/
-					const Jupiter::ReadableString &getPrefixes() const;
+					std::string_view getPrefixes() const;
 
 					/**
 					* @brief Fetches the user's nickname.
@@ -322,7 +322,7 @@ namespace Jupiter
 				*
 				* @return String containing the name of the channel.
 				*/
-				const Jupiter::ReadableString &getName() const;
+				std::string_view getName() const;
 
 				/**
 				* @brief Searches for a user based on their nickname.
@@ -417,7 +417,7 @@ namespace Jupiter
 				* @param channelName String containing the name of a channel.
 				* @param iFace Server in which this channel is located.
 				*/
-				Channel(const Jupiter::ReadableString &in_name, Client *in_parent);
+				Channel(std::string_view in_name, Client *in_parent);
 
 			/** Private members */
 			private:
@@ -509,7 +509,7 @@ namespace Jupiter
 			*
 			* @return String containing the server's name.
 			*/
-			const Jupiter::ReadableString &getServerName() const;
+			std::string_view getServerName() const;
 
 			/**
 			* @brief Returns the server's hostname.
@@ -693,7 +693,7 @@ namespace Jupiter
 			* @param message String containing the message to send.
 			* @return Number of messages sent.
 			*/
-			size_t messageChannels(const Jupiter::ReadableString &in_message);
+			size_t messageChannels(std::string_view in_message);
 
 			/**
 			* @brief Returns if the client will automatically reconnect upon failure.
@@ -715,7 +715,7 @@ namespace Jupiter
 			*
 			* @param rawMessage String containing the data to send.
 			*/
-			void send(const Jupiter::ReadableString &in_message);
+			void send(std::string_view in_message);
 
 			/**
 			* @brief Processes an input line of IRC protocol data.
@@ -732,7 +732,7 @@ namespace Jupiter
 			* @param in_default_value Optional parameter specifying the default value to return if none is found.
 			* @return String containing the key value if it exists, in_default_value otherwise.
 			*/
-			std::string_view readConfigValue(const Jupiter::ReadableString &key, std::string_view in_default_value = std::string_view{}) const;
+			std::string_view readConfigValue(std::string_view key, std::string_view in_default_value = std::string_view{}) const;
 
 			/**
 			* @brief Returns a key's value as a boolean.
@@ -741,7 +741,7 @@ namespace Jupiter
 			* @param key String containing the key name.
 			* @return Boolean value of the key value if it exists, in_default_value otherwise.
 			*/
-			bool readConfigBool(const Jupiter::ReadableString &key, bool in_default_value = false) const;
+			bool readConfigBool(std::string_view key, bool in_default_value = false) const;
 
 			/**
 			* @brief Returns a key's value as an integer.
@@ -750,7 +750,7 @@ namespace Jupiter
 			* @param key String containing the key name.
 			* @return Integer value of the key value if it exists, in_default_value otherwise.
 			*/
-			int readConfigInt(const Jupiter::ReadableString &key, int in_default_value = 0) const;
+			int readConfigInt(std::string_view key, int in_default_value = 0) const;
 
 			/**
 			* @brief Returns a key's value as a long integer.
@@ -759,7 +759,7 @@ namespace Jupiter
 			* @param key String containing the key name.
 			* @return Long integer value of the key value if it exists, in_default_value otherwise.
 			*/
-			long readConfigLong(const Jupiter::ReadableString &key, long in_default_value = 0) const;
+			long readConfigLong(std::string_view key, long in_default_value = 0) const;
 
 			/**
 			* @brief Returns a key's value as a double.
@@ -768,14 +768,14 @@ namespace Jupiter
 			* @param key String containing the key name.
 			* @return Double value of the key value if it exists, in_default_value otherwise.
 			*/
-			double readConfigDouble(const Jupiter::ReadableString &key, double in_default_value = 0) const;
+			double readConfigDouble(std::string_view key, double in_default_value = 0) const;
 
 			/**
 			* @brief Writes to the server's log file.
 			*
 			* @param message String containing the text to write to the file.
 			*/
-			void writeToLogs(const Jupiter::ReadableString &in_message);
+			void writeToLogs(std::string_view in_message);
 
 			/**
 			* @brief Connects the client to its server.
@@ -797,7 +797,7 @@ namespace Jupiter
 			*
 			* @param message String containing the QUIT message to send prior to disconnecting.
 			*/
-			void disconnect(const Jupiter::ReadableString &in_message, bool in_stay_dead = false);
+			void disconnect(std::string_view in_message, bool in_stay_dead = false);
 
 			/**
 			* @brief Calls disconnect() if the client has not already, then calls connect().
@@ -845,7 +845,7 @@ namespace Jupiter
 			Jupiter::Config *m_secondary_section;
 			std::string m_log_file_name;
 			std::string m_last_line;
-			Jupiter::StringS m_server_name;
+			std::string m_server_name;
 			std::string m_nickname;
 			std::string m_realname;
 
@@ -877,7 +877,7 @@ namespace Jupiter
 
 			bool startCAP();
 			bool registerClient();
-			std::shared_ptr<User> findUser(const Jupiter::ReadableString &in_nickname) const;
+			std::shared_ptr<User> findUser(std::string_view in_nickname) const;
 			std::shared_ptr<User> findUserOrAdd(std::string_view in_nickname);
 		}; // Jupiter::IRC::Client class
 

src/include/Jupiter/Plugin.h

@@ -88,7 +88,7 @@ namespace Jupiter
 		*
 		* @return String containing the name of the plugin.
 		*/
-		const Jupiter::ReadableString &getName() const;
+		std::string_view getName() const;
 
 		/**
 		* @brief Returns the plugin's configuration file.
@@ -296,7 +296,7 @@ namespace Jupiter
 		*
 		* @param dir Directory to look for plugins in.
 		*/
-		static void setDirectory(const Jupiter::ReadableString &dir);
+		static void setDirectory(std::string_view dir);
 
 		/**
 		* @brief Returns the current plugin directory.
@@ -310,7 +310,7 @@ namespace Jupiter
 		*
 		* @param dir Directory to look for configuration files in.
 		*/
-		static void setConfigDirectory(const Jupiter::ReadableString &dir);
+		static void setConfigDirectory(std::string_view dir);
 
 		/**
 		* @brief Returns the current plugin configuration directory

src/include/Jupiter/Reference_String.h

@@ -34,7 +34,7 @@ namespace Jupiter {
 
 	namespace literals {
 		/** DEPRECATED: Reference_String literals */
-		inline Jupiter::ReferenceString operator"" _jrs(const char *str, size_t len) { return Jupiter::ReferenceString(str, len); }
+		inline constexpr std::string_view operator"" _jrs(const char *str, size_t len) { return { str, len }; }
 	}
 }
 

src/include/Jupiter/Socket.h

@@ -355,14 +355,14 @@ namespace Jupiter
 		* @param size The size of the buffer to be made.
 		* @return The newly created buffer.
 		*/
-		const Jupiter::ReadableString &setBufferSize(size_t size);
+		std::string_view setBufferSize(size_t size);
 
 		/**
 		* @brief Copies any new socket data to the buffer and returns it.
 		*
 		* @return Socket buffer if new data is successfully received, an empty buffer otherwise.
 		*/
-		const Jupiter::ReadableString &getData();
+		std::string_view getData();
 
 		/**
 		* @brief Returns the local hostname of the local machine.

src/include/Jupiter/String.hpp

@@ -167,159 +167,6 @@ namespace Jupiter
 	template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const std::basic_string_view<T> &rhs);
 	template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const T *rhs);
 
-	/**
-	* @brief Provides a "loose" String implementation that's more optimized for repeated concatenations.
-	* Note: The underlying string will always have a size which is a power of 2, but no fewer than 8 elements.
-	*
-	* @param T Element type which the String will store. Defaults to char.
-	*/
-	template<typename T = char> class String_Loose : public Shift_String_Type<T>
-	{
-	public:
-
-		/**
-		* @brief Returns the maximum number of elements the String can contain,
-		* without expanding the socket buffer. This is generally the size of the
-		* underlying memory buffer.
-		*
-		* @return Number of elements the string can contain without reallocation.
-		*/
-		virtual size_t capacity() const;
-
-		/**
-		* @brief Sets the String's contents based on the format string and input variables.
-		* Note: Format specifiers similar to printf. Returns 0 for any type other than char and wchar_t.
-		*
-		* @param format Format that the string is compared against.
-		* @param args Inputs to match the format specifiers.
-		* @return Number of characters written.
-		*/
-		size_t vformat(const T *format, va_list args);
-
-		/**
-		* @brief Appends to a String's contents based on the format string and input variables.
-		* Note: Format specifiers similar to printf. Returns 0 for any type other than char and wchar_t.
-		*
-		* @param format Format that the string is compared against.
-		* @param args Inputs to match the format specifiers.
-		* @return Number of characters written.
-		*/
-		size_t avformat(const T *format, va_list args);
-
-		/**
-		* @brief Sets the String's contents based on the format string and input variables.
-		* Note: Format specifiers similar to printf. Returns 0 for any type other than char and wchar_t.
-		*
-		* @param format Format that the string is compared against.
-		* @param ... Inputs to match the format specifiers.
-		* @return String containing the new format.
-		*/
-		static String_Loose<T> Format(const T *format, ...);
-
-		/**
-		* @brief Creates a partial copy of the string.
-		*
-		* @param pos Position in the string to start copying from.
-		* @return String containing a partial copy of the original string.
-		*/
-		typename Jupiter::template String_Loose<T> substring(size_t pos) const;
-
-		/**
-		* @brief Creates a partial copy of the string.
-		*
-		* @param pos Position in the string to start copying from.
-		* @param length Number of characters to copy.
-		* @return String containing a partial copy of the original string.
-		*/
-		typename Jupiter::template String_Loose<T> substring(size_t pos, size_t length) const;
-
-		/**
-		* @brief Creates a partial copy of the string.
-		*
-		* @param in String to get a partial copy of.
-		* @param pos Position in the string to start copying from.
-		* @return String containing a partial copy of the original string.
-		*/
-		static typename Jupiter::template String_Loose<T> substring(const Jupiter::Readable_String<T> &in, size_t pos);
-		static typename Jupiter::template String_Loose<T> substring(const T *in, size_t pos);
-
-		/**
-		* @brief Creates a partial copy of the string.
-		*
-		* @param in String to get a partial copy of.
-		* @param pos Position in the string to start copying from.
-		* @param length Number of characters to copy.
-		* @return String containing a partial copy of the original string.
-		*/
-		static typename Jupiter::template String_Loose<T> substring(const Jupiter::Readable_String<T> &in, size_t pos, size_t length);
-		static typename Jupiter::template String_Loose<T> substring(const T *in, size_t pos, size_t length);
-
-		/**
-		* @brief Sets the internal buffer to be at least large enough to old a specified number of elements.
-		* Note: This does nothing if len is less than the string's current length.
-		*
-		* @param len Minimum number of elements the string buffer must be able to hold.
-		* @return True if a new buffer was allocated, false otherwise.
-		*/
-		virtual bool setBufferSize(size_t len) override;
-
-		/**
-		* @brief Empties the string, and sets the internal buffer to be at least large enough to old a specified number of elements.
-		* Note: This does nothing if len is less than the string's current length.
-		*
-		* @param len Minimum number of elements the string buffer must be able to hold.
-		* @return True if a new buffer was allocated, false otherwise.
-		*/
-		virtual bool setBufferSizeNoCopy(size_t len) override;
-
-		/** Default constructor */
-		String_Loose();
-
-		/**
-		* @brief Size hint constructor.
-		*
-		* @param size Minimum number of elements the string must be able to hold.
-		*/
-		String_Loose(size_t size);
-
-		/** Move Constructor */
-		String_Loose(String_Loose<T> &&source);
-
-		/** Copy Constructors */
-		String_Loose(const String_Loose<T> &in);
-		String_Loose(const Readable_String<T> &in);
-		String_Loose(const std::basic_string<T> &in);
-		String_Loose(const T *in, size_t len);
-		String_Loose(const T *in);
-		String_Loose(const Jupiter::DataBuffer &in);
-
-		/** Concatenation Constructors */
-		String_Loose(const Readable_String<T> &lhs, const T &rhs);
-		String_Loose(const Readable_String<T> &lhs, const Readable_String<T> &rhs);
-		String_Loose(const Readable_String<T> &lhs, const std::basic_string<T> &rhs);
-		String_Loose(const Readable_String<T> &lhs, const T *rhs);
-		String_Loose(const Readable_String<T> &lhs, const T *rhs, size_t rhs_size);
-
-		/** Addition Operators */
-		inline String_Loose<T> operator+(const T &rhs) const;
-		inline String_Loose<T> operator+(const String_Loose<T> &rhs) const;
-		inline String_Loose<T> operator+(const Readable_String<T> &rhs) const;
-		inline String_Loose<T> operator+(const std::basic_string<T> &rhs) const;
-		inline String_Loose<T> operator+(const T *rhs) const;
-
-		/** Assignment Operators */
-		inline String_Loose<T> &operator=(const String_Loose<T> &right) { this->set(right); return *this; };
-		inline String_Loose<T> &operator=(const Readable_String<T> &right) { this->set(right); return *this; };
-		inline String_Loose<T> &operator=(const std::basic_string<T> &right) { this->set(right); return *this; };
-		inline String_Loose<T> &operator=(const T *right) { this->set(right); return *this; };
-		inline String_Loose<T> &operator=(const T right) { this->set(right); return *this; };
-
-		static const size_t start_size = 8; /** Starting size for loose Strings. */
-
-	protected:
-		size_t strSize; /** Size of underlying string buffer */
-	};
-
 	/** Definition of a Strict String. */
 	typedef String_Strict<char> StringS;
 

src/include/Jupiter/String_Imp.h

@@ -343,7 +343,7 @@ template<typename T> static inline Jupiter::String_Strict<T> Jupiter::operator+(
 template<> struct _Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Strict>
 {
 	template<typename Y> static void push(Jupiter::DataBuffer *buffer, const Jupiter::String_Strict<Y> *data) {
-		_Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Strict>::push<Y>(buffer, data);
+		_Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Type>::push<Y>(buffer, data);
 	};
 
 	template<typename Y> static Jupiter::String_Strict<Y> interpret(uint8_t *&head)
@@ -356,371 +356,4 @@ template<> struct _Jupiter_DataBuffer_partial_specialization_impl<Jupiter::Strin
 	}
 };
 
-/**
-* IMPLEMENTATION:
-*	String_Loose
-*/
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose() : Jupiter::String_Loose<T>::String_Loose(Jupiter::String_Loose<T>::start_size)
-{
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(Jupiter::String_Loose<T> &&source) : Jupiter::Shift_String_Type<T>(std::move(source))
-{
-	Jupiter::String_Loose<T>::strSize = source.strSize;
-	source.strSize = 0;
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(size_t len)
-{
-	if (len > Jupiter::String_Loose<T>::start_size) Jupiter::String_Loose<T>::strSize = len;
-	else Jupiter::String_Loose<T>::strSize = Jupiter::String_Loose<T>::start_size;
-
-	Jupiter::Shift_String_Type<T>::base = new T[Jupiter::String_Loose<T>::strSize];
-	Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-	Jupiter::String_Type<T>::length = 0;
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::String_Loose<T> &in)
-{
-	Jupiter::String_Loose<T>::strSize = in.strSize;
-	Jupiter::Shift_String_Type<T>::base = new T[Jupiter::String_Loose<T>::strSize];
-	Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-	for (Jupiter::String_Type<T>::length = 0; Jupiter::String_Type<T>::length != in.length; Jupiter::String_Type<T>::length++)
-		Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length] = in.get(Jupiter::String_Type<T>::length);
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::Readable_String<T> &in) : Jupiter::String_Loose<T>::String_Loose(
-	in.data(), in.size())
-{
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const std::basic_string<T> &in) : Jupiter::String_Loose<T>::String_Loose(in.data(), in.size())
-{
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const T *in, size_t len) : Jupiter::String_Loose<T>::String_Loose(len)
-{
-	while (Jupiter::String_Type<T>::length != len)
-	{
-		Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length] = *in;
-		++in, ++Jupiter::String_Type<T>::length;
-	}
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const T *in)
-{
-	if (in == nullptr)
-	{
-		Jupiter::String_Loose<T>::strSize = Jupiter::String_Loose<T>::start_size;
-		Jupiter::Shift_String_Type<T>::base = new T[Jupiter::String_Loose<T>::strSize];
-		Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-		Jupiter::String_Type<T>::length = 0;
-	}
-	else
-	{
-		Jupiter::String_Type<T>::length = Jupiter::strlen<T>(in);
-
-		Jupiter::String_Loose<T>::strSize = getPowerTwo(Jupiter::String_Type<T>::length);
-		if (Jupiter::String_Loose<T>::strSize < Jupiter::String_Loose<T>::start_size) Jupiter::String_Loose<T>::strSize = Jupiter::String_Loose<T>::start_size;
-
-		Jupiter::Shift_String_Type<T>::base = new T[Jupiter::String_Loose<T>::strSize];
-		Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-		for (Jupiter::String_Type<T>::length = 0; *in != 0; Jupiter::String_Type<T>::length++, in++) Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length] = *in;
-	}
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::DataBuffer &in) : String_Loose(reinterpret_cast<T *>(in.getHead()), in.size() / sizeof(T))
-{
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::Readable_String<T> &lhs, const T &rhs) : String_Loose<T>(lhs.size() + 1)
-{
-	const T *itr;
-	const T *end;
-
-	if (!lhs.empty())
-	{
-		itr = lhs.data();
-		end = itr + lhs.size();
-		*Jupiter::String_Type<T>::str = *itr;
-		while (++itr != end)
-			*++Jupiter::String_Type<T>::str = *itr;
-		++Jupiter::String_Type<T>::str;
-	}
-
-	*Jupiter::String_Type<T>::str = rhs;
-
-	Jupiter::String_Type<T>::length = Jupiter::String_Type<T>::str - Jupiter::Shift_String_Type<T>::base + 1;
-	Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::Readable_String<T> &lhs, const Jupiter::Readable_String<T> &rhs) : String_Loose<T>(lhs,
-	rhs.data(), rhs.size())
-{
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::Readable_String<T> &lhs, const std::basic_string<T> &rhs) : String_Loose<T>(lhs, rhs.data(), rhs.size())
-{
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::Readable_String<T> &lhs, const T *rhs) : String_Loose<T>(lhs, rhs, Jupiter::strlen<T>(rhs))
-{
-}
-
-template<typename T> Jupiter::String_Loose<T>::String_Loose(const Jupiter::Readable_String<T> &lhs, const T *rhs, size_t rhs_size) : String_Loose<T>(lhs.size() + rhs_size)
-{
-	const T *itr;
-	const T *end;
-
-	if (!lhs.empty())
-	{
-		itr = lhs.data();
-		end = itr + lhs.size();
-		*Jupiter::String_Type<T>::str = *itr;
-		while (++itr != end)
-			*++Jupiter::String_Type<T>::str = *itr;
-		++Jupiter::String_Type<T>::str;
-	}
-
-	if (rhs_size != 0)
-	{
-		itr = rhs;
-		end = itr + rhs_size;
-		*Jupiter::String_Type<T>::str = *itr;
-		while (++itr != end)
-			*++Jupiter::String_Type<T>::str = *itr;
-		++Jupiter::String_Type<T>::str;
-	}
-
-	Jupiter::String_Type<T>::length = Jupiter::String_Type<T>::str - Jupiter::Shift_String_Type<T>::base;
-	Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-}
-
-template<typename T> bool Jupiter::String_Loose<T>::setBufferSize(size_t len)
-{
-	size_t offset = Jupiter::String_Type<T>::str - Jupiter::Shift_String_Type<T>::base;
-
-	if (len + offset > Jupiter::String_Loose<T>::strSize)
-	{
-		if (len > Jupiter::String_Loose<T>::strSize)
-		{
-			// Buffer is not large enough; reallocate
-			Jupiter::String_Loose<T>::strSize = getPowerTwo(len);
-
-			T *ptr = new T[Jupiter::String_Loose<T>::strSize];
-			for (size_t i = 0; i < Jupiter::String_Type<T>::length; i++)
-				ptr[i] = Jupiter::String_Type<T>::str[i];
-
-			delete[] Jupiter::Shift_String_Type<T>::base;
-			Jupiter::Shift_String_Type<T>::base = ptr;
-			Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-
-			return true;
-		}
-
-		// Buffer has enough space to accomodate; shift data to the left
-		T *read_itr = Jupiter::String_Type<T>::str;
-		T *read_end = read_itr + Jupiter::String_Type<T>::length;
-		T *write_itr = Jupiter::Shift_String_Type<T>::base;
-
-		while (read_itr != read_end)
-		{
-			*write_itr = *read_itr;
-
-			++read_itr;
-			++write_itr;
-		}
-
-		Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-	}
-
-	return false;
-}
-
-template<typename T> bool Jupiter::String_Loose<T>::setBufferSizeNoCopy(size_t len)
-{
-	len = getPowerTwo(len);
-	if (len > Jupiter::String_Loose<T>::strSize)
-	{
-		Jupiter::String_Type<T>::length = 0;
-		delete[] Jupiter::Shift_String_Type<T>::base;
-		Jupiter::Shift_String_Type<T>::base = new T[len];
-		Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-		return true;
-	}
-
-	Jupiter::String_Type<T>::length = 0;
-	Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base;
-
-	return false;
-}
-
-// vformat()
-
-template<> size_t inline Jupiter::String_Loose<char>::vformat(const char *format, va_list args)
-{
-	int minLen;
-	va_list sargs;
-	va_copy(sargs, args);
-	minLen = JUPITER_VSCPRINTF(format, sargs);
-	va_end(sargs);
-	if (minLen < 0) return 0; // We simply can not work with this.
-
-	this->setBufferSizeNoCopy(minLen + 1); // vsnprintf REQUIRES space for an additional null character.
-	minLen = vsnprintf(Jupiter::String_Type<char>::str, minLen + 1, format, args);
-	if (minLen < 0) return 0;
-	return Jupiter::String_Type<char>::length = minLen;
-}
-
-template<> size_t inline Jupiter::String_Loose<wchar_t>::vformat(const wchar_t *format, va_list args)
-{
-	int minLen;
-	va_list sargs;
-	va_copy(sargs, args);
-	minLen = JUPITER_VSCWPRINTF(format, sargs);
-	va_end(sargs);
-	if (minLen < 0) return 0; // We simply can not work with this.
-
-	this->setBufferSizeNoCopy(minLen + 1); // vsnprintf REQUIRES space for an additional null character.
-	minLen = vswprintf(Jupiter::String_Type<wchar_t>::str, minLen + 1, format, args);
-	if (minLen < 0) return 0;
-	return Jupiter::String_Type<wchar_t>::length = minLen;
-}
-
-template<typename T> size_t Jupiter::String_Loose<T>::capacity() const
-{
-	return Jupiter::String_Loose<T>::strSize;
-}
-
-template<typename T> size_t Jupiter::String_Loose<T>::vformat(const T *format, va_list args)
-{
-	return 0;
-}
-
-// avformat()
-
-template<> size_t inline Jupiter::String_Loose<char>::avformat(const char *format, va_list args)
-{
-	int minLen;
-	va_list sargs;
-	va_copy(sargs, args);
-	minLen = JUPITER_VSCPRINTF(format, sargs);
-	va_end(sargs);
-	if (minLen < 0) return 0; // We simply can not work with this.
-
-	this->setBufferSize(Jupiter::String_Type<char>::length + minLen + 1); // vsnprintf REQUIRES space for an additional null character.
-	minLen = vsnprintf(Jupiter::String_Type<char>::str + Jupiter::String_Type<char>::length, minLen + 1, format, args);
-	if (minLen <= 0) return 0;
-	Jupiter::String_Type<char>::length += minLen;
-	return minLen;
-}
-
-template<> size_t inline Jupiter::String_Loose<wchar_t>::avformat(const wchar_t *format, va_list args)
-{
-	int minLen;
-	va_list sargs;
-	va_copy(sargs, args);
-	minLen = JUPITER_VSCWPRINTF(format, sargs);
-	va_end(sargs);
-	if (minLen < 0) return 0; // We simply can not work with this.
-	this->setBufferSize(minLen + Jupiter::String_Type<wchar_t>::length + 1); // vsnprintf REQUIRES space for an additional null character.
-
-	minLen = vswprintf(Jupiter::String_Type<wchar_t>::str + Jupiter::String_Type<wchar_t>::length, minLen + 1, format, args);
-	if (minLen <= 0) return 0;
-	Jupiter::String_Type<wchar_t>::length += minLen;
-	return minLen;
-}
-
-template<typename T> size_t Jupiter::String_Loose<T>::avformat(const T *format, va_list args)
-{
-	return 0;
-}
-
-template<typename T> Jupiter::String_Loose<T> Jupiter::String_Loose<T>::Format(const T *format, ...)
-{
-	String_Loose<T> r;
-	va_list args;
-	va_start(args, format);
-	r.vformat(format, args);
-	va_end(args);
-	return r;
-}
-
-template<typename T> typename Jupiter::template String_Loose<T> Jupiter::String_Loose<T>::substring(size_t pos) const
-{
-	return Jupiter::String_Loose<T>::substring(*this, pos);
-}
-
-template<typename T> typename Jupiter::template String_Loose<T> Jupiter::String_Loose<T>::substring(size_t pos, size_t length) const
-{
-	return Jupiter::String_Loose<T>::substring(*this, pos, length);
-}
-
-template<typename T> typename Jupiter::template String_Loose<T> Jupiter::String_Loose<T>::substring(const Jupiter::Readable_String<T> &in, size_t pos)
-{
-	return Jupiter::String_Type<T>::template substring<Jupiter::template String_Loose>(in, pos);
-}
-
-template<typename T> typename Jupiter::template String_Loose<T> Jupiter::String_Loose<T>::substring(const T *in, size_t pos)
-{
-	return Jupiter::String_Type<T>::template substring<Jupiter::template String_Loose>(in, pos);
-}
-
-template<typename T> typename Jupiter::template String_Loose<T> Jupiter::String_Loose<T>::substring(const Jupiter::Readable_String<T> &in, size_t pos, size_t len)
-{
-	return Jupiter::String_Type<T>::template substring<Jupiter::template String_Loose>(in, pos, len);
-}
-
-template<typename T> typename Jupiter::template String_Loose<T> Jupiter::String_Loose<T>::substring(const T *in, size_t pos, size_t len)
-{
-	return Jupiter::String_Type<T>::template substring<Jupiter::template String_Loose>(in, pos, len);
-}
-
-// Operators
-
-template<typename T> inline Jupiter::String_Loose<T> Jupiter::String_Loose<T>::operator+(const T &rhs) const
-{
-	return Jupiter::operator+(*this, rhs);
-}
-
-template<typename T> inline Jupiter::String_Loose<T> Jupiter::String_Loose<T>::operator+(const Jupiter::String_Loose<T> &rhs) const
-{
-	return Jupiter::String_Loose<T>::operator+(reinterpret_cast<const Jupiter::Readable_String<T> &>(rhs));
-}
-
-template<typename T> inline Jupiter::String_Loose<T> Jupiter::String_Loose<T>::operator+(const Jupiter::Readable_String<T> &rhs) const
-{
-	return Jupiter::operator+(*this, rhs);
-}
-
-template<typename T> inline Jupiter::String_Loose<T> Jupiter::String_Loose<T>::operator+(const std::basic_string<T> &rhs) const
-{
-	return Jupiter::operator+(*this, rhs);
-}
-
-template<typename T> inline Jupiter::String_Loose<T> Jupiter::String_Loose<T>::operator+(const T *rhs) const
-{
-	return Jupiter::operator+(*this, rhs);
-}
-
-// Jupiter::DataBuffer specialization
-
-template<> struct _Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Loose>
-{
-	template<typename Y> static void push(Jupiter::DataBuffer *buffer, const Jupiter::String_Loose<Y> *data)
-	{
-		_Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Type>::push<Y>(buffer, data);
-	};
-
-	template<typename Y> static Jupiter::String_Loose<Y> interpret(uint8_t *&head)
-	{
-		size_t size_ = *reinterpret_cast<size_t *>(head);
-		head += sizeof(size_t);
-		Jupiter::String_Loose<Y> r = Jupiter::String_Loose<Y>(reinterpret_cast<Y *>(head), size_);
-		head += size_;
-		return r;
-	}
-};
-
 #endif // _STRING_IMP_H_HEADER