From 772b2ec0243d7b55d91e4027d828881d18093ed0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Remko=20Tron=C3=A7on?= <git@el-tramo.be>
Date: Tue, 3 May 2011 22:39:27 +0200
Subject: Replace ByteArray by typedef.


diff --git a/QA/Checker/IO.cpp b/QA/Checker/IO.cpp
new file mode 100644
index 0000000..4945791
--- /dev/null
+++ b/QA/Checker/IO.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2010 Remko Tronçon
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#include <QA/Checker/IO.h>
+
+#include <iostream>
+
+std::ostream& operator<<(std::ostream& os, const Swift::ByteArray& s) {
+	std::ios::fmtflags oldFlags = os.flags(); 
+	os << std::hex;
+	for (Swift::ByteArray::const_iterator i = s.begin(); i != s.end(); ++i) {
+		os << "0x" << static_cast<unsigned int>(static_cast<unsigned char>(*i));
+		if (i + 1 < s.end()) {
+			os << " ";
+		}
+	}
+	os << std::endl;
+	os.flags(oldFlags);
+	return os;
+}
diff --git a/QA/Checker/IO.h b/QA/Checker/IO.h
new file mode 100644
index 0000000..5eb61d8
--- /dev/null
+++ b/QA/Checker/IO.h
@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2010 Remko Tronçon
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#pragma once
+
+#include <Swiften/Base/ByteArray.h>
+
+std::ostream& operator<<(std::ostream& os, const Swift::ByteArray& s);
diff --git a/QA/Checker/SConscript b/QA/Checker/SConscript
index 0456b93..96479db 100644
--- a/QA/Checker/SConscript
+++ b/QA/Checker/SConscript
@@ -11,4 +11,4 @@ if env["TEST"] :
 	if env["SCONS_STAGE"] == "build" :
 			checker_env = env.Clone()
 			checker_env.MergeFlags(env["CPPUNIT_FLAGS"])
-			checker_env.Library("Checker", "checker.cpp")
+			checker_env.Library("Checker", ["checker.cpp", "IO.cpp"])
diff --git a/Slimber/FileVCardCollection.cpp b/Slimber/FileVCardCollection.cpp
index c6984c7..97ade08 100644
--- a/Slimber/FileVCardCollection.cpp
+++ b/Slimber/FileVCardCollection.cpp
@@ -22,11 +22,11 @@ FileVCardCollection::FileVCardCollection(boost::filesystem::path dir) : vcardsPa
 boost::shared_ptr<VCard> FileVCardCollection::getOwnVCard() const {
 	if (boost::filesystem::exists(vcardsPath / std::string("vcard.xml"))) {
 		ByteArray data;
-		data.readFromFile(boost::filesystem::path(vcardsPath / std::string("vcard.xml")).string());
+		readByteArrayFromFile(data, boost::filesystem::path(vcardsPath / std::string("vcard.xml")).string());
 
 		VCardParser parser;
 		PayloadParserTester tester(&parser);
-		tester.parse(data.toString());
+		tester.parse(byteArrayToString(data));
 		return boost::dynamic_pointer_cast<VCard>(parser.getPayload());
 	}
 	else {
diff --git a/SwifTools/Notifier/GrowlNotifier.cpp b/SwifTools/Notifier/GrowlNotifier.cpp
index 46355e9..c9397f1 100644
--- a/SwifTools/Notifier/GrowlNotifier.cpp
+++ b/SwifTools/Notifier/GrowlNotifier.cpp
@@ -74,12 +74,12 @@ GrowlNotifier::GrowlNotifier(const std::string& name) {
 
 void GrowlNotifier::showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picturePath, boost::function<void()> callback) {
 	ByteArray picture;
-	picture.readFromFile(picturePath.string());
+	readByteArrayFromFile(picture, picturePath.string());
 
 	CFStringRef cfSubject = SWIFTEN_STRING_TO_CFSTRING(subject);
 	CFStringRef cfDescription = SWIFTEN_STRING_TO_CFSTRING(description);
 	CFStringRef cfName = SWIFTEN_STRING_TO_CFSTRING(typeToString(type));
-	CFDataRef cfIcon = CFDataCreate( NULL, (UInt8*) picture.getData(), picture.getSize());
+	CFDataRef cfIcon = CFDataCreate( NULL, (UInt8*) vecptr(picture), picture.size());
 	
 	Context context(callback);
 	CFDataRef cfContextData[1];
diff --git a/Swift/Controllers/MainController.cpp b/Swift/Controllers/MainController.cpp
index c00c080..f85fcd8 100644
--- a/Swift/Controllers/MainController.cpp
+++ b/Swift/Controllers/MainController.cpp
@@ -575,7 +575,7 @@ void MainController::handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>
 }
 
 void MainController::handleVCardReceived(const JID& jid, VCard::ref vCard) {
-	if (!jid.equals(jid_, JID::WithoutResource) || !vCard || vCard->getPhoto().isEmpty()) {
+	if (!jid.equals(jid_, JID::WithoutResource) || !vCard || vCard->getPhoto().empty()) {
 		return;
 	}
 	std::string hash = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));
diff --git a/Swift/Controllers/Storages/AvatarFileStorage.cpp b/Swift/Controllers/Storages/AvatarFileStorage.cpp
index 288f6fd..b39e586 100644
--- a/Swift/Controllers/Storages/AvatarFileStorage.cpp
+++ b/Swift/Controllers/Storages/AvatarFileStorage.cpp
@@ -59,7 +59,7 @@ void AvatarFileStorage::addAvatar(const std::string& hash, const ByteArray& avat
 		}
 	}
 	boost::filesystem::ofstream file(avatarPath, boost::filesystem::ofstream::binary|boost::filesystem::ofstream::out);
-	file.write(reinterpret_cast<const char*>(avatar.getData()), static_cast<std::streamsize>(avatar.getSize()));
+	file.write(reinterpret_cast<const char*>(vecptr(avatar)), static_cast<std::streamsize>(avatar.size()));
 	file.close();
 }
 
@@ -69,7 +69,7 @@ boost::filesystem::path AvatarFileStorage::getAvatarPath(const std::string& hash
 
 ByteArray AvatarFileStorage::getAvatar(const std::string& hash) const {
 	ByteArray data;
-	data.readFromFile(getAvatarPath(hash).string());
+	readByteArrayFromFile(data, getAvatarPath(hash).string());
 	return data;
 }
 
diff --git a/Swift/Controllers/Storages/CertificateFileStorage.cpp b/Swift/Controllers/Storages/CertificateFileStorage.cpp
index 31af949..a4a95c7 100644
--- a/Swift/Controllers/Storages/CertificateFileStorage.cpp
+++ b/Swift/Controllers/Storages/CertificateFileStorage.cpp
@@ -23,7 +23,7 @@ bool CertificateFileStorage::hasCertificate(Certificate::ref certificate) const
 	boost::filesystem::path certificatePath = getCertificatePath(certificate);
 	if (boost::filesystem::exists(certificatePath)) {
 		ByteArray data;
-		data.readFromFile(certificatePath.string());
+		readByteArrayFromFile(data, certificatePath.string());
 		Certificate::ref storedCertificate = certificateFactory->createCertificateFromDER(data);
 		if (storedCertificate && storedCertificate->toDER() == certificate->toDER()) {
 			return true;
@@ -50,7 +50,7 @@ void CertificateFileStorage::addCertificate(Certificate::ref certificate) {
 	}
 	boost::filesystem::ofstream file(certificatePath, boost::filesystem::ofstream::binary|boost::filesystem::ofstream::out);
 	ByteArray data = certificate->toDER();
-	file.write(reinterpret_cast<const char*>(data.getData()), data.getSize());
+	file.write(reinterpret_cast<const char*>(vecptr(data)), data.size());
 	file.close();
 }
 
diff --git a/Swift/Controllers/Storages/VCardFileStorage.cpp b/Swift/Controllers/Storages/VCardFileStorage.cpp
index 4933d0c..5f657a4 100644
--- a/Swift/Controllers/Storages/VCardFileStorage.cpp
+++ b/Swift/Controllers/Storages/VCardFileStorage.cpp
@@ -79,7 +79,7 @@ std::string VCardFileStorage::getPhotoHash(const JID& jid) const {
 
 std::string VCardFileStorage::getAndUpdatePhotoHash(const JID& jid, VCard::ref vCard) const {
 	std::string hash;
-	if (vCard && !vCard->getPhoto().isEmpty()) {
+	if (vCard && !vCard->getPhoto().empty()) {
 		hash = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));
 	}
 	std::pair<PhotoHashMap::iterator, bool> r = photoHashes.insert(std::make_pair(jid, hash));
diff --git a/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp b/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp
index d1c5bbe..3e9be13 100644
--- a/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp
+++ b/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp
@@ -144,7 +144,7 @@ class PresenceNotifierTest : public CppUnit::TestFixture {
 
 		void testNotificationPicture() {
 			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			avatarManager->avatars[user1] = ByteArray("abcdef");
+			avatarManager->avatars[user1] = createByteArray("abcdef");
 
 			sendPresence(user1, StatusShow::Online);
 
diff --git a/Swift/QtUI/QtAvatarWidget.cpp b/Swift/QtUI/QtAvatarWidget.cpp
index 3e3aa69..1efb787 100644
--- a/Swift/QtUI/QtAvatarWidget.cpp
+++ b/Swift/QtUI/QtAvatarWidget.cpp
@@ -47,8 +47,8 @@ void QtAvatarWidget::setAvatar(const ByteArray& data, const std::string& type) {
 	this->type = type;
 
 	QImage image;
-	if (!data.isEmpty()) {
-		image.loadFromData(reinterpret_cast<const uchar*>(data.getData()), data.getSize());
+	if (!data.empty()) {
+		image.loadFromData(reinterpret_cast<const uchar*>(vecptr(data)), data.size());
 	}
 
 	if (image.isNull()) {
@@ -81,10 +81,10 @@ void QtAvatarWidget::mousePressEvent(QMouseEvent* event) {
 		QString fileName = QFileDialog::getOpenFileName(this, tr("Select picture"), "", tr("Image Files (*.png *.jpg *.gif)"));
 		if (!fileName.isEmpty()) {
 			ByteArray data;
-			data.readFromFile(Q2PSTRING(fileName));
+			readByteArrayFromFile(data, Q2PSTRING(fileName));
 
 			QBuffer buffer;
-			buffer.setData(reinterpret_cast<const char*>(data.getData()), data.getSize());
+			buffer.setData(reinterpret_cast<const char*>(vecptr(data)), data.size());
 			buffer.open(QIODevice::ReadOnly);
 			QString type = QImageReader::imageFormat(&buffer).toLower();
 			if (!type.isEmpty()) {
diff --git a/Swiften/Avatars/AvatarStorage.h b/Swiften/Avatars/AvatarStorage.h
index d1aff39..c33d38b 100644
--- a/Swiften/Avatars/AvatarStorage.h
+++ b/Swiften/Avatars/AvatarStorage.h
@@ -8,10 +8,10 @@
 
 #include <boost/filesystem/path.hpp>
 #include <string>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class JID;
-	class ByteArray;
 
 	class AvatarStorage {
 		public:
diff --git a/Swiften/Avatars/UnitTest/VCardAvatarManagerTest.cpp b/Swiften/Avatars/UnitTest/VCardAvatarManagerTest.cpp
index 23b4169..1c23821 100644
--- a/Swiften/Avatars/UnitTest/VCardAvatarManagerTest.cpp
+++ b/Swiften/Avatars/UnitTest/VCardAvatarManagerTest.cpp
@@ -10,6 +10,7 @@
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <boost/bind.hpp>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Elements/VCard.h>
 #include <Swiften/Avatars/VCardAvatarManager.h>
 #include <Swiften/Avatars/AvatarMemoryStorage.h>
@@ -42,7 +43,7 @@ class VCardAvatarManagerTest : public CppUnit::TestFixture {
 			avatarStorage = new AvatarMemoryStorage();
 			vcardStorage = new VCardMemoryStorage();
 			vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);
-			avatar1 = ByteArray("abcdefg");
+			avatar1 = createByteArray("abcdefg");
 			avatar1Hash = Hexify::hexify(SHA1::getHash(avatar1));
 			user1 = JID("user1@bar.com/bla");
 			user2 = JID("user2@foo.com/baz");
diff --git a/Swiften/Avatars/UnitTest/VCardUpdateAvatarManagerTest.cpp b/Swiften/Avatars/UnitTest/VCardUpdateAvatarManagerTest.cpp
index 2a3b3fd..966e4ef 100644
--- a/Swiften/Avatars/UnitTest/VCardUpdateAvatarManagerTest.cpp
+++ b/Swiften/Avatars/UnitTest/VCardUpdateAvatarManagerTest.cpp
@@ -10,6 +10,7 @@
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <boost/bind.hpp>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Elements/VCardUpdate.h>
 #include <Swiften/Avatars/VCardUpdateAvatarManager.h>
 #include <Swiften/Avatars/AvatarMemoryStorage.h>
@@ -44,7 +45,7 @@ class VCardUpdateAvatarManagerTest : public CppUnit::TestFixture {
 			avatarStorage = new AvatarMemoryStorage();
 			vcardStorage = new VCardMemoryStorage();
 			vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);
-			avatar1 = ByteArray("abcdefg");
+			avatar1 = createByteArray("abcdefg");
 			avatar1Hash = Hexify::hexify(SHA1::getHash(avatar1));
 			user1 = JID("user1@bar.com/bla");
 			user2 = JID("user2@foo.com/baz");
@@ -163,7 +164,7 @@ class VCardUpdateAvatarManagerTest : public CppUnit::TestFixture {
 
 		IQ::ref createVCardResult(const ByteArray& avatar) {
 			VCard::ref vcard(new VCard());
-			if (!avatar.isEmpty()) {
+			if (!avatar.empty()) {
 				vcard->setPhoto(avatar);
 			}
 			return IQ::createResult(JID("baz@fum.com"), stanzaChannel->sentStanzas[0]->getID(), vcard);
diff --git a/Swiften/Avatars/VCardUpdateAvatarManager.cpp b/Swiften/Avatars/VCardUpdateAvatarManager.cpp
index 26665c1..0c3ad23 100644
--- a/Swiften/Avatars/VCardUpdateAvatarManager.cpp
+++ b/Swiften/Avatars/VCardUpdateAvatarManager.cpp
@@ -50,7 +50,7 @@ void VCardUpdateAvatarManager::handleVCardChanged(const JID& from, VCard::ref vC
 		return;
 	}
 
-	if (vCard->getPhoto().isEmpty()) {
+	if (vCard->getPhoto().empty()) {
 		setAvatarHash(from, "");
 	}
 	else {
diff --git a/Swiften/Base/Algorithm.h b/Swiften/Base/Algorithm.h
index f0c6b48..c1cd0d3 100644
--- a/Swiften/Base/Algorithm.h
+++ b/Swiften/Base/Algorithm.h
@@ -88,6 +88,11 @@ namespace Swift {
 		Detail::eraseIfImpl(container, predicate, typename Detail::ContainerTraits<C>::Category());
 	}
 
+	template<typename C>
+	void append(C& target, const C& source) {
+		target.insert(target.end(), source.begin(), source.end());
+	}
+
 	/*
 	 * Functors
 	 */
diff --git a/Swiften/Base/ByteArray.cpp b/Swiften/Base/ByteArray.cpp
index 8c8b215..10da395 100644
--- a/Swiften/Base/ByteArray.cpp
+++ b/Swiften/Base/ByteArray.cpp
@@ -8,44 +8,26 @@
 
 #include <fstream>
 
-std::ostream& operator<<(std::ostream& os, const Swift::ByteArray& s) {
-	return operator<<(os, s.getDataVector());
-}
-
-std::ostream& operator<<(std::ostream& os, const std::vector<unsigned char>& s) {
-	std::ios::fmtflags oldFlags = os.flags(); 
-	os << std::hex;
-	for (Swift::ByteArray::const_iterator i = s.begin(); i != s.end(); ++i) {
-		os << "0x" << static_cast<unsigned int>(static_cast<unsigned char>(*i));
-		if (i + 1 < s.end()) {
-			os << " ";
-		}
-	}
-	os << std::endl;
-	os.flags(oldFlags);
-	return os;
-}
-
 namespace Swift {
 
 static const int BUFFER_SIZE = 4096;
 
-void ByteArray::readFromFile(const std::string& file) {
+void readByteArrayFromFile(ByteArray& data, const std::string& file) {
 	std::ifstream input(file.c_str(), std::ios_base::in|std::ios_base::binary);
 	while (input.good()) {
-		size_t oldSize = data_.size();
-		data_.resize(oldSize + BUFFER_SIZE);
-		input.read(reinterpret_cast<char*>(&data_[oldSize]), BUFFER_SIZE);
-		data_.resize(oldSize + input.gcount());
+		size_t oldSize = data.size();
+		data.resize(oldSize + BUFFER_SIZE);
+		input.read(reinterpret_cast<char*>(&data[oldSize]), BUFFER_SIZE);
+		data.resize(oldSize + input.gcount());
 	}
 	input.close();
 }
 
-std::vector<unsigned char> ByteArray::create(const std::string& s) {
+std::vector<unsigned char> createByteArray(const std::string& s) {
 	return std::vector<unsigned char>(s.begin(), s.end());
 }
 
-std::vector<unsigned char> ByteArray::create(const char* c) {
+std::vector<unsigned char> createByteArray(const char* c) {
 	std::vector<unsigned char> data;
 	while (*c) {
 		data.push_back(static_cast<unsigned char>(*c));
@@ -54,32 +36,26 @@ std::vector<unsigned char> ByteArray::create(const char* c) {
 	return data;
 }
 
-std::vector<unsigned char> ByteArray::create(const char* c, size_t n) {
-	std::vector<unsigned char> data;
-	if (n > 0) {
-		data.resize(n);
-		memcpy(&data[0], c, n);
-	}
+std::vector<unsigned char> createByteArray(const char* c, size_t n) {
+	std::vector<unsigned char> data(n);
+	std::copy(c, c + n, data.begin());
 	return data;
 }
 
-std::vector<unsigned char> ByteArray::create(const unsigned char* c, size_t n) {
-	std::vector<unsigned char> data;
-	if (n > 0) {
-		data.resize(n);
-		memcpy(&data[0], c, n);
-	}
+std::vector<unsigned char> createByteArray(const unsigned char* c, size_t n) {
+	std::vector<unsigned char> data(n);
+	std::copy(c, c + n, data.begin());
 	return data;
 }
 
-std::string ByteArray::toString() const {
+std::string byteArrayToString(const ByteArray& b) {
 	size_t i;
-	for (i = data_.size(); i > 0; --i) {
-		if (data_[i - 1] != 0) {
+	for (i = b.size(); i > 0; --i) {
+		if (b[i - 1] != 0) {
 			break;
 		}
 	}
-	return i > 0 ? std::string(reinterpret_cast<const char*>(getData()), i) : "";
+	return i > 0 ? std::string(reinterpret_cast<const char*>(vecptr(b)), i) : "";
 }
 
 }
diff --git a/Swiften/Base/ByteArray.h b/Swiften/Base/ByteArray.h
index ebc22d8..8ef8dd6 100644
--- a/Swiften/Base/ByteArray.h
+++ b/Swiften/Base/ByteArray.h
@@ -8,147 +8,32 @@
 
 #include <vector>
 #include <string>
-#include <cstring> // for memcpy
 
 namespace Swift {
-	class ByteArray
-	{
-		public:
-			typedef std::vector<unsigned char>::const_iterator const_iterator;
+	typedef std::vector<unsigned char> ByteArray;
 
-			ByteArray() : data_() {}
+	ByteArray createByteArray(const unsigned char* c, size_t n);
+	ByteArray createByteArray(const std::string& s);
+	ByteArray createByteArray(const char* c);
+	ByteArray createByteArray(const char* c, size_t n);
 
-			ByteArray(const std::string& s) : data_(s.begin(), s.end()) {}
+	inline ByteArray createByteArray(char c) {
+		return std::vector<unsigned char>(1, c);
+	}
 
-			ByteArray(const char* c) {
-				while (*c) {
-					data_.push_back(static_cast<unsigned char>(*c));
-					++c;
-				}
-			}
 
-			ByteArray(const char* c, size_t n) {
-				if (n > 0) {
-					data_.resize(n);
-					memcpy(&data_[0], c, n);
-				}
-			}
+	template<typename T, typename A>
+	static const T* vecptr(const std::vector<T, A>& v) {
+		return v.empty() ? NULL : &v[0];
+	}
 
-			ByteArray(const unsigned char* c, size_t n) {
-				if (n > 0) {
-					data_.resize(n);
-					memcpy(&data_[0], c, n);
-				}
-			}
+	template<typename T, typename A>
+	static T* vecptr(std::vector<T, A>& v) {
+		return v.empty() ? NULL : &v[0];
+	}
 
-			ByteArray(const std::vector<unsigned char>& data) : data_(data) {
-			}
+	std::string byteArrayToString(const ByteArray& b);
 
-			const unsigned char* getData() const {
-				return data_.empty() ? NULL : &data_[0];
-			}
-
-			unsigned char* getData() {
-				return data_.empty() ? NULL : &data_[0];
-			}
-			
-			const std::vector<unsigned char>& getVector() const {
-				return data_;
-			}
-
-			std::vector<unsigned char>& getVector() {
-				return data_;
-			}
-
-			size_t getSize() const {
-				return data_.size();
-			}
-
-			bool isEmpty() const {
-				return data_.empty();
-			}
-
-			void resize(size_t size) {
-				return data_.resize(size);
-			}
-
-			void resize(size_t size, char c) {
-				return data_.resize(size, static_cast<unsigned char>(c));
-			}
-
-			friend ByteArray operator+(const ByteArray& a, const ByteArray&b) {
-				ByteArray result(a);
-				result.data_.insert(result.data_.end(), b.data_.begin(), b.data_.end());
-				return result;
-			}
-
-			friend ByteArray operator+(const ByteArray& a, char b) {
-				ByteArray x;
-				x.resize(1);
-				x[0] = static_cast<unsigned char>(b);
-				return a + x;
-			}
-
-			ByteArray& operator+=(const ByteArray& b) {
-				data_.insert(data_.end(), b.data_.begin(), b.data_.end());
-				return *this;
-			}
-
-			ByteArray& operator+=(char c) {
-				data_.push_back(static_cast<unsigned char>(c));
-				return *this;
-			}
-
-			friend bool operator==(const ByteArray& a, const ByteArray& b) {
-				return a.data_ == b.data_;
-			}
-
-
-			const unsigned char& operator[](size_t i) const {
-				return data_[i];
-			}
-
-			unsigned char& operator[](size_t i) {
-				return data_[i];
-			}
-
-			const_iterator begin() const { 
-				return data_.begin(); 
-			}
-		
-			const_iterator end() const { 
-				return data_.end(); 
-			}
-
-			std::string toString() const;
-
-			void readFromFile(const std::string& file);
-
-			void clear() {
-				data_.clear();
-			}
-
-			const std::vector<unsigned char>& getDataVector() const {
-				return data_;
-			}
-
-			static std::vector<unsigned char> create(const std::string& s);
-			static std::vector<unsigned char> create(const char* c);
-			static std::vector<unsigned char> create(const unsigned char* c, size_t n);
-			static std::vector<unsigned char> create(const char* c, size_t n);
-
-			static const unsigned char* data(const std::vector<unsigned char>& v) {
-				return v.empty() ? NULL : &v[0];
-			}
-
-			static const char* charData(const std::vector<unsigned char>& v) {
-				return v.empty() ? NULL : reinterpret_cast<const char*>(&v[0]);
-			}
-
-		private:
-			std::vector<unsigned char> data_;
-	};
+	void readByteArrayFromFile(ByteArray&, const std::string& file);
 }
 
-std::ostream& operator<<(std::ostream& os, const Swift::ByteArray& s);
-std::ostream& operator<<(std::ostream& os, const std::vector<unsigned char>& s);
diff --git a/Swiften/Base/Concat.h b/Swiften/Base/Concat.h
new file mode 100644
index 0000000..83a43b6
--- /dev/null
+++ b/Swiften/Base/Concat.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2011 Remko Tronçon
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#pragma once
+
+namespace Swift {
+	template<typename C>
+	C concat(const C& c1, const C& c2) {
+		C result;
+		result.resize(c1.size() + c2.size());
+		std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()));
+		return result;
+	}
+
+	template<typename C>
+	C concat(const C& c1, const C& c2, const C& c3) {
+		C result;
+		result.resize(c1.size() + c2.size() + c3.size());
+		std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())));
+		return result;
+	}
+
+	template<typename C>
+	C concat(const C& c1, const C& c2, const C& c3, const C& c4) {
+		C result;
+		result.resize(c1.size() + c2.size() + c3.size() + c4.size());
+		std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))));
+		return result;
+	}
+
+	template<typename C>
+	C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5) {
+		C result;
+		result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size());
+		std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))));
+		return result;
+	}
+
+	template<typename C>
+	C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6) {
+		C result;
+		result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size());
+		std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))))));
+		return result;
+	}
+
+	template<typename C>
+	C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7) {
+		C result;
+		result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size());
+		std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))))));
+		return result;
+	}
+
+	template<typename C>
+	C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7, const C& c8) {
+		C result;
+		result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size() + c8.size());
+		std::copy(c8.begin(), c8.end(), std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))))))));
+		return result;
+	}
+
+	template<typename C>
+	C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7, const C& c8, const C& c9) {
+		C result;
+		result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size() + c8.size() + c9.size());
+		std::copy(c9.begin(), c9.end(), std::copy(c8.begin(), c8.end(), std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))))))));
+		return result;
+	}
+}
diff --git a/Swiften/Base/Paths.cpp b/Swiften/Base/Paths.cpp
index d901ff9..b40f9b8 100644
--- a/Swiften/Base/Paths.cpp
+++ b/Swiften/Base/Paths.cpp
@@ -24,22 +24,22 @@ boost::filesystem::path Paths::getExecutablePath() {
 	ByteArray path;
 	uint32_t size = 4096;
 	path.resize(size);
-	if (_NSGetExecutablePath(reinterpret_cast<char*>(path.getData()), &size) == 0) {
-		return boost::filesystem::path(std::string(reinterpret_cast<const char*>(path.getData()), path.getSize()).c_str()).parent_path();
+	if (_NSGetExecutablePath(const_cast<char*>(reinterpret_cast<const char*>(vecptr(path))), &size) == 0) {
+		return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(path)), path.size()).c_str()).parent_path();
 	}
 #elif defined(SWIFTEN_PLATFORM_LINUX)
 	ByteArray path;
 	path.resize(4096);
-	size_t size = readlink("/proc/self/exe", reinterpret_cast<char*>(path.getData()), path.getSize());
+	size_t size = readlink("/proc/self/exe", reinterpret_cast<char*>(vecptr(path)), path.size());
 	if (size > 0) {
 		path.resize(size);
-		return boost::filesystem::path(std::string(reinterpret_cast<const char*>(path.getData()), path.getSize()).c_str()).parent_path();
+		return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(path)), path.size()).c_str()).parent_path();
 	}
 #elif defined(SWIFTEN_PLATFORM_WINDOWS)
 	ByteArray data;
 	data.resize(2048);
-	GetModuleFileName(NULL, reinterpret_cast<char*>(data.getData()), data.getSize());
-	return boost::filesystem::path(std::string(reinterpret_cast<const char*>(data.getData()), data.getSize()).c_str()).parent_path();
+	GetModuleFileName(NULL, reinterpret_cast<char*>(vecptr(data)), data.size());
+	return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(data)), data.size()).c_str()).parent_path();
 #endif
 	return boost::filesystem::path();
 }
diff --git a/Swiften/Base/UnitTest/ByteArrayTest.cpp b/Swiften/Base/UnitTest/ByteArrayTest.cpp
index b663166..ecd0439 100644
--- a/Swiften/Base/UnitTest/ByteArrayTest.cpp
+++ b/Swiften/Base/UnitTest/ByteArrayTest.cpp
@@ -25,31 +25,31 @@ class ByteArrayTest : public CppUnit::TestFixture {
 		void testGetData_NoData() {
 			ByteArray testling;
 
-			CPPUNIT_ASSERT_EQUAL(reinterpret_cast<const char*>(NULL), reinterpret_cast<const char*>(testling.getData()));
+			CPPUNIT_ASSERT_EQUAL(reinterpret_cast<const char*>(NULL), reinterpret_cast<const char*>(vecptr(testling)));
 		}
 
 		void testToString() {
-			ByteArray testling(ByteArray::create("abcde"));
+			ByteArray testling(createByteArray("abcde"));
 
-			CPPUNIT_ASSERT_EQUAL(std::string("abcde"), testling.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));
 		}
 
 		void testToString_NullTerminated() {
-			ByteArray testling(ByteArray::create("abcde\0", 6));
+			ByteArray testling(createByteArray("abcde\0", 6));
 
-			CPPUNIT_ASSERT_EQUAL(std::string("abcde"), testling.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));
 		}
 
 		void testToString_TwoNullTerminated() {
-			ByteArray testling(ByteArray::create("abcde\0\0", 7));
+			ByteArray testling(createByteArray("abcde\0\0", 7));
 
-			CPPUNIT_ASSERT_EQUAL(std::string("abcde"), testling.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));
 		}
 
 		void testToString_AllNull() {
-			ByteArray testling(ByteArray::create("\0\0", 2));
+			ByteArray testling(createByteArray("\0\0", 2));
 
-			CPPUNIT_ASSERT_EQUAL(std::string(""), testling.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string(""), byteArrayToString(testling));
 		}
 };
 
diff --git a/Swiften/Client/ClientSession.cpp b/Swiften/Client/ClientSession.cpp
index a2f6a70..da81ce4 100644
--- a/Swiften/Client/ClientSession.cpp
+++ b/Swiften/Client/ClientSession.cpp
@@ -10,6 +10,7 @@
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_io.hpp>
 #include <boost/uuid/uuid_generators.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
 
 #include <Swiften/Elements/ProtocolHeader.h>
 #include <Swiften/Elements/StreamFeatures.h>
@@ -184,7 +185,7 @@ void ClientSession::handleElement(boost::shared_ptr<Element> element) {
 			if (stream->hasTLSCertificate()) {
 				if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {
 					state = Authenticating;
-					stream->writeElement(boost::shared_ptr<Element>(new AuthRequest("EXTERNAL", "")));
+					stream->writeElement(boost::make_shared<AuthRequest>("EXTERNAL", createByteArray("")));
 				}
 				else {
 					finishSession(Error::TLSClientCertificateError);
@@ -192,7 +193,7 @@ void ClientSession::handleElement(boost::shared_ptr<Element> element) {
 			}
 			else if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {
 				state = Authenticating;
-				stream->writeElement(boost::shared_ptr<Element>(new AuthRequest("EXTERNAL", "")));
+				stream->writeElement(boost::make_shared<AuthRequest>("EXTERNAL", createByteArray("")));
 			}
 			else if (streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1") || streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1-PLUS")) {
 				std::ostringstream s;
@@ -265,7 +266,7 @@ void ClientSession::handleElement(boost::shared_ptr<Element> element) {
 		checkState(Authenticating);
 		assert(authenticator);
 		if (authenticator->setChallenge(challenge->getValue())) {
-			stream->writeElement(boost::shared_ptr<AuthResponse>(new AuthResponse(authenticator->getResponse())));
+			stream->writeElement(boost::make_shared<AuthResponse>(authenticator->getResponse()));
 		}
 		else {
 			finishSession(Error::AuthenticationFailedError);
diff --git a/Swiften/Component/ComponentHandshakeGenerator.cpp b/Swiften/Component/ComponentHandshakeGenerator.cpp
index fce71ac..79ba9b3 100644
--- a/Swiften/Component/ComponentHandshakeGenerator.cpp
+++ b/Swiften/Component/ComponentHandshakeGenerator.cpp
@@ -18,7 +18,7 @@ std::string ComponentHandshakeGenerator::getHandshake(const std::string& streamI
 	String::replaceAll(concatenatedString, '>', "&gt;");
 	String::replaceAll(concatenatedString, '\'', "&apos;");
 	String::replaceAll(concatenatedString, '"', "&quot;");
-	return Hexify::hexify(SHA1::getHash(ByteArray(concatenatedString)));
+	return Hexify::hexify(SHA1::getHash(createByteArray(concatenatedString)));
 }
 
 }
diff --git a/Swiften/Compress/UnitTest/ZLibCompressorTest.cpp b/Swiften/Compress/UnitTest/ZLibCompressorTest.cpp
index 8b3a48b..9320ae1 100644
--- a/Swiften/Compress/UnitTest/ZLibCompressorTest.cpp
+++ b/Swiften/Compress/UnitTest/ZLibCompressorTest.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Compress/ZLibCompressor.h>
 
 using namespace Swift;
@@ -26,17 +27,17 @@ class ZLibCompressorTest : public CppUnit::TestFixture
 
 		void testProcess() {
 			ZLibCompressor testling;
-			ByteArray result = testling.process("foo");
+			ByteArray result = testling.process(createByteArray("foo"));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11), result);
 		}
 
 		void testProcess_Twice() {
 			ZLibCompressor testling;
-			testling.process("foo");
-			ByteArray result = testling.process("bar");
+			testling.process(createByteArray("foo"));
+			ByteArray result = testling.process(createByteArray("bar"));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x4a\x4a\x2c\x02\x00\x00\x00\xff\xff",9), result); 
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x4a\x4a\x2c\x02\x00\x00\x00\xff\xff",9), result); 
 		}
 };
 
diff --git a/Swiften/Compress/UnitTest/ZLibDecompressorTest.cpp b/Swiften/Compress/UnitTest/ZLibDecompressorTest.cpp
index 7a26d50..00aae6e 100644
--- a/Swiften/Compress/UnitTest/ZLibDecompressorTest.cpp
+++ b/Swiften/Compress/UnitTest/ZLibDecompressorTest.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Compress/ZLibDecompressor.h>
 #include <Swiften/Compress/ZLibCompressor.h>
 #include <Swiften/Compress/ZLibException.h>
@@ -31,22 +32,22 @@ class ZLibDecompressorTest : public CppUnit::TestFixture
 
 		void testProcess() {
 			ZLibDecompressor testling;
-			ByteArray result = testling.process(ByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11));
+			ByteArray result = testling.process(createByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("foo"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("foo"), result);
 		}
 
 		void testProcess_Twice() {
 			ZLibDecompressor testling;
-			testling.process(ByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11));
-			ByteArray result = testling.process(ByteArray("\x4a\x4a\x2c\x02\x00\x00\x00\xff\xff", 9)); 
+			testling.process(createByteArray("\x78\xda\x4a\xcb\xcf\x07\x00\x00\x00\xff\xff", 11));
+			ByteArray result = testling.process(createByteArray("\x4a\x4a\x2c\x02\x00\x00\x00\xff\xff", 9)); 
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("bar"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("bar"), result);
 		}
 
 		void testProcess_Invalid() {
 			ZLibDecompressor testling;
-			CPPUNIT_ASSERT_THROW(testling.process(ByteArray("invalid")), ZLibException);
+			CPPUNIT_ASSERT_THROW(testling.process(createByteArray("invalid")), ZLibException);
 		}
 
 		void testProcess_Huge() {
@@ -55,7 +56,7 @@ class ZLibDecompressorTest : public CppUnit::TestFixture
 			for (unsigned int i = 0; i < 2048; ++i) {
 				data.push_back(static_cast<char>(i));
 			}
-			ByteArray original(&data[0], data.size());
+			ByteArray original(createByteArray(&data[0], data.size()));
 			ByteArray compressed = ZLibCompressor().process(original);
 			ByteArray decompressed = ZLibDecompressor().process(compressed);
 
@@ -68,7 +69,7 @@ class ZLibDecompressorTest : public CppUnit::TestFixture
 			for (unsigned int i = 0; i < 1024; ++i) {
 				data.push_back(static_cast<char>(i));
 			}
-			ByteArray original(&data[0], data.size());
+			ByteArray original(createByteArray(&data[0], data.size()));
 			ByteArray compressed = ZLibCompressor().process(original);
 			ByteArray decompressed = ZLibDecompressor().process(compressed);
 
diff --git a/Swiften/Compress/ZLibCodecompressor.cpp b/Swiften/Compress/ZLibCodecompressor.cpp
index 1fb3a94..872c154 100644
--- a/Swiften/Compress/ZLibCodecompressor.cpp
+++ b/Swiften/Compress/ZLibCodecompressor.cpp
@@ -7,6 +7,7 @@
 #include <Swiften/Compress/ZLibCodecompressor.h>
 
 #include <cassert>
+#include <string.h>
 
 #include <Swiften/Compress/ZLibException.h>
 
@@ -26,13 +27,13 @@ ZLibCodecompressor::~ZLibCodecompressor() {
 
 ByteArray ZLibCodecompressor::process(const ByteArray& input) {
 	ByteArray output;
-	stream_.avail_in = input.getSize();
-	stream_.next_in = reinterpret_cast<Bytef*>(const_cast<unsigned char*>(input.getData()));
+	stream_.avail_in = input.size();
+	stream_.next_in = reinterpret_cast<Bytef*>(const_cast<unsigned char*>(vecptr(input)));
 	int outputPosition = 0;
 	do {
 		output.resize(outputPosition + CHUNK_SIZE);
 		stream_.avail_out = CHUNK_SIZE;
-		stream_.next_out = reinterpret_cast<Bytef*>(output.getData() + outputPosition);
+		stream_.next_out = reinterpret_cast<Bytef*>(vecptr(output) + outputPosition);
 		int result = processZStream();
 		if (result != Z_OK && result != Z_BUF_ERROR) {
 			throw ZLibException(/* stream_.msg */);
diff --git a/Swiften/Disco/CapsInfoGenerator.cpp b/Swiften/Disco/CapsInfoGenerator.cpp
index 7992a06..6d84984 100644
--- a/Swiften/Disco/CapsInfoGenerator.cpp
+++ b/Swiften/Disco/CapsInfoGenerator.cpp
@@ -57,7 +57,7 @@ CapsInfo CapsInfoGenerator::generateCapsInfo(const DiscoInfo& discoInfo) const {
 		}
 	}
 
-	std::string version(Base64::encode(SHA1::getHash(serializedCaps)));
+	std::string version(Base64::encode(SHA1::getHash(createByteArray(serializedCaps))));
 	return CapsInfo(node_, version, "sha-1");
 }
 
diff --git a/Swiften/Elements/AuthChallenge.h b/Swiften/Elements/AuthChallenge.h
index 124919c..f7f2796 100644
--- a/Swiften/Elements/AuthChallenge.h
+++ b/Swiften/Elements/AuthChallenge.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <boost/optional.hpp>
+#include <vector>
 
-#include <Swiften/Base/ByteArray.h>
 #include <Swiften/Elements/Element.h>
 
 namespace Swift {
@@ -17,18 +17,18 @@ namespace Swift {
 			AuthChallenge() {
 			}
 
-			AuthChallenge(const ByteArray& value) : value(value) {
+			AuthChallenge(const std::vector<unsigned char>& value) : value(value) {
 			}
 
-			const boost::optional<ByteArray>& getValue() const {
+			const boost::optional< std::vector<unsigned char> >& getValue() const {
 				return value;
 			}
 
-			void setValue(const ByteArray& value) {
-				this->value = boost::optional<ByteArray>(value);
+			void setValue(const std::vector<unsigned char>& value) {
+				this->value = boost::optional<std::vector<unsigned char> >(value);
 			}
 
 		private:
-			boost::optional<ByteArray> value;
+			boost::optional< std::vector<unsigned char> > value;
 	};
 }
diff --git a/Swiften/Elements/AuthRequest.h b/Swiften/Elements/AuthRequest.h
index 3b3bd1a..5e4e4ab 100644
--- a/Swiften/Elements/AuthRequest.h
+++ b/Swiften/Elements/AuthRequest.h
@@ -6,9 +6,10 @@
 
 #pragma once
 
+#include <vector>
+#include <string>
 #include <boost/optional.hpp>
 
-#include <Swiften/Base/ByteArray.h>
 #include <Swiften/Elements/Element.h>
 
 namespace Swift {
@@ -17,20 +18,20 @@ namespace Swift {
 			AuthRequest(const std::string& mechanism = "") : mechanism_(mechanism) {
 			}
 
-			AuthRequest(const std::string& mechanism, const ByteArray& message) : 
+			AuthRequest(const std::string& mechanism, const std::vector<unsigned char>& message) : 
 					mechanism_(mechanism), message_(message) {
 			}
 
-			AuthRequest(const std::string& mechanism, const boost::optional<ByteArray>& message) : 
+			AuthRequest(const std::string& mechanism, const boost::optional<std::vector<unsigned char> >& message) : 
 					mechanism_(mechanism), message_(message) {
 			}
 
-			const boost::optional<ByteArray>& getMessage() const {
+			const boost::optional<std::vector<unsigned char> >& getMessage() const {
 				return message_;
 			}
 
-			void setMessage(const ByteArray& message) {
-				message_ = boost::optional<ByteArray>(message);
+			void setMessage(const std::vector<unsigned char>& message) {
+				message_ = boost::optional<std::vector<unsigned char> >(message);
 			}
 
 			const std::string& getMechanism() const {
@@ -43,6 +44,6 @@ namespace Swift {
 
 		private:
 			std::string mechanism_;
-			boost::optional<ByteArray> message_;
+			boost::optional<std::vector<unsigned char> > message_;
 	};
 }
diff --git a/Swiften/Elements/AuthResponse.h b/Swiften/Elements/AuthResponse.h
index 30b76d3..a616005 100644
--- a/Swiften/Elements/AuthResponse.h
+++ b/Swiften/Elements/AuthResponse.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
+#include <vector>
 #include <boost/optional.hpp>
 
-#include <Swiften/Base/ByteArray.h>
 #include <Swiften/Elements/Element.h>
 
 namespace Swift {
@@ -17,21 +17,21 @@ namespace Swift {
 			AuthResponse() {
 			}
 
-			AuthResponse(const ByteArray& value) : value(value) {
+			AuthResponse(const std::vector<unsigned char>& value) : value(value) {
 			}
 
-			AuthResponse(const boost::optional<ByteArray>& value) : value(value) {
+			AuthResponse(const boost::optional<std::vector<unsigned char> >& value) : value(value) {
 			}
 
-			const boost::optional<ByteArray>& getValue() const {
+			const boost::optional<std::vector<unsigned char> >& getValue() const {
 				return value;
 			}
 
-			void setValue(const ByteArray& value) {
-				this->value = boost::optional<ByteArray>(value);
+			void setValue(const std::vector<unsigned char>& value) {
+				this->value = boost::optional<std::vector<unsigned char> >(value);
 			}
 
 		private:
-			boost::optional<ByteArray> value;
+			boost::optional<std::vector<unsigned char> > value;
 	};
 }
diff --git a/Swiften/Elements/AuthSuccess.h b/Swiften/Elements/AuthSuccess.h
index 85091e6..3c0f329 100644
--- a/Swiften/Elements/AuthSuccess.h
+++ b/Swiften/Elements/AuthSuccess.h
@@ -6,25 +6,25 @@
 
 #pragma once
 
+#include <vector>
 #include <boost/optional.hpp>
 
 #include <Swiften/Elements/Element.h>
-#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class AuthSuccess : public Element {
 		public:
 			AuthSuccess() {}
 
-			const boost::optional<ByteArray>& getValue() const {
+			const boost::optional<std::vector<unsigned char> >& getValue() const {
 				return value;
 			}
 
-			void setValue(const ByteArray& value) {
-				this->value = boost::optional<ByteArray>(value);
+			void setValue(const std::vector<unsigned char>& value) {
+				this->value = boost::optional<std::vector<unsigned char> >(value);
 			}
 
 		private:
-			boost::optional<ByteArray> value;
+			boost::optional<std::vector<unsigned char> > value;
 	};
 }
diff --git a/Swiften/Entity/PayloadPersister.cpp b/Swiften/Entity/PayloadPersister.cpp
index ac5a578..955135b 100644
--- a/Swiften/Entity/PayloadPersister.cpp
+++ b/Swiften/Entity/PayloadPersister.cpp
@@ -41,10 +41,10 @@ void PayloadPersister::savePayload(boost::shared_ptr<Payload> payload, const boo
 boost::shared_ptr<Payload> PayloadPersister::loadPayload(const boost::filesystem::path& path) {
 	if (boost::filesystem::exists(path)) {
 		ByteArray data;
-		data.readFromFile(path.string());
+		readByteArrayFromFile(data, path.string());
 		boost::shared_ptr<PayloadParser> parser(createParser());
 		PayloadParserTester tester(parser.get());
-		tester.parse(data.toString());
+		tester.parse(byteArrayToString(data));
 		return parser->getPayload();
 	}
 	else {
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamServer.cpp b/Swiften/FileTransfer/SOCKS5BytestreamServer.cpp
index bc2d259..9731d2d 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamServer.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamServer.cpp
@@ -34,7 +34,7 @@ void SOCKS5BytestreamServer::removeBytestream(const std::string& id, const JID&
 }
 
 std::string SOCKS5BytestreamServer::getSOCKSDestinationAddress(const std::string& id, const JID& from, const JID& to) {
-	return Hexify::hexify(SHA1::getHash(ByteArray(id + from.toString() + to.toString())));
+	return Hexify::hexify(SHA1::getHash(createByteArray(id + from.toString() + to.toString())));
 }
 
 void SOCKS5BytestreamServer::handleNewConnection(boost::shared_ptr<Connection> connection) {
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp
index 46cfb3a..fadfd46 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp
@@ -10,6 +10,8 @@
 #include <iostream>
 
 #include <Swiften/Base/ByteArray.h>
+#include <Swiften/Base/Algorithm.h>
+#include <Swiften/Base/Concat.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>
 #include <Swiften/FileTransfer/BytestreamException.h>
 
@@ -35,51 +37,51 @@ void SOCKS5BytestreamServerSession::stop() {
 }
 
 void SOCKS5BytestreamServerSession::handleDataRead(const ByteArray& data) {
-	unprocessedData += data;
+	append(unprocessedData, data);
 	process();
 }
 
 void SOCKS5BytestreamServerSession::process() {
 	if (state == WaitingForAuthentication) {
-		if (unprocessedData.getSize() >= 2) {
+		if (unprocessedData.size() >= 2) {
 			size_t authCount = unprocessedData[1];
 			size_t i = 2;
-			while (i < 2 + authCount && i < unprocessedData.getSize()) {
+			while (i < 2 + authCount && i < unprocessedData.size()) {
 				// Skip authentication mechanism
 				++i;
 			}
 			if (i == 2 + authCount) {
 				// Authentication message is complete
-				if (i != unprocessedData.getSize()) {
+				if (i != unprocessedData.size()) {
 					std::cerr << "SOCKS5BytestreamServerSession: Junk after authentication mechanism";
 				}
 				unprocessedData.clear();
-				connection->write(ByteArray("\x05\x00", 2));
+				connection->write(createByteArray("\x05\x00", 2));
 				state = WaitingForRequest;
 			}
 		}
 	}
 	else if (state == WaitingForRequest) {
-		if (unprocessedData.getSize() >= 5) {
+		if (unprocessedData.size() >= 5) {
 			ByteArray requestID;
 			size_t i = 5;
 			size_t hostnameSize = unprocessedData[4];
-			while (i < 5 + hostnameSize && i < unprocessedData.getSize()) {
-				requestID += unprocessedData[i];
+			while (i < 5 + hostnameSize && i < unprocessedData.size()) {
+				requestID.push_back(unprocessedData[i]);
 				++i;
 			}
 			// Skip the port:
 			i += 2;
-			if (i >= unprocessedData.getSize()) {
-				if (i != unprocessedData.getSize()) {
+			if (i >= unprocessedData.size()) {
+				if (i != unprocessedData.size()) {
 					std::cerr << "SOCKS5BytestreamServerSession: Junk after authentication mechanism";
 				}
-				bytestream = bytestreams->getBytestream(requestID.toString());
-				ByteArray result("\x05", 1);
-				result += bytestream ? 0x0 : 0x4;
-				result += ByteArray("\x00\x03", 2);
-				result += static_cast<char>(requestID.getSize());
-				result += requestID + ByteArray("\x00\x00", 2);
+				bytestream = bytestreams->getBytestream(byteArrayToString(requestID));
+				ByteArray result = createByteArray("\x05", 1);
+				result.push_back(bytestream ? 0x0 : 0x4);
+				append(result, createByteArray("\x00\x03", 2));
+				result.push_back(static_cast<char>(requestID.size()));
+				append(result, concat(requestID, createByteArray("\x00\x00", 2)));
 				if (!bytestream) {
 					connection->write(result);
 					finish(true);
diff --git a/Swiften/FileTransfer/UnitTest/IBBReceiveSessionTest.cpp b/Swiften/FileTransfer/UnitTest/IBBReceiveSessionTest.cpp
index e022a5d..e759624 100644
--- a/Swiften/FileTransfer/UnitTest/IBBReceiveSessionTest.cpp
+++ b/Swiften/FileTransfer/UnitTest/IBBReceiveSessionTest.cpp
@@ -58,10 +58,10 @@ class IBBReceiveSessionTest : public CppUnit::TestFixture {
 			testling->start();
 			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));
 
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));
 
 			CPPUNIT_ASSERT(stanzaChannel->isResultAtIndex(1, "id-a"));
-			CPPUNIT_ASSERT(ByteArray::create("abc") == receivedData);
+			CPPUNIT_ASSERT(createByteArray("abc") == receivedData);
 			CPPUNIT_ASSERT(!finished);
 
 			testling->stop();
@@ -72,11 +72,11 @@ class IBBReceiveSessionTest : public CppUnit::TestFixture {
 			testling->start();
 			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));
 
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, ByteArray::create("def")), "foo@bar.com/baz", "id-b"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, createByteArray("def")), "foo@bar.com/baz", "id-b"));
 
 			CPPUNIT_ASSERT(stanzaChannel->isResultAtIndex(2, "id-b"));
-			CPPUNIT_ASSERT(ByteArray::create("abcdef") == receivedData);
+			CPPUNIT_ASSERT(createByteArray("abcdef") == receivedData);
 			CPPUNIT_ASSERT(!finished);
 
 			testling->stop();
@@ -87,7 +87,7 @@ class IBBReceiveSessionTest : public CppUnit::TestFixture {
 			testling->start();
 			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));
 
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("othersession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("othersession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));
 
 			CPPUNIT_ASSERT(stanzaChannel->isErrorAtIndex(1, "id-a"));
 
@@ -99,8 +99,8 @@ class IBBReceiveSessionTest : public CppUnit::TestFixture {
 			testling->start();
 			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));
 
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("def")), "foo@bar.com/baz", "id-b"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("def")), "foo@bar.com/baz", "id-b"));
 
 			CPPUNIT_ASSERT(stanzaChannel->isErrorAtIndex(2, "id-b"));
 			CPPUNIT_ASSERT(finished);
@@ -114,11 +114,11 @@ class IBBReceiveSessionTest : public CppUnit::TestFixture {
 			testling->start();
 			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));
 
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));
-			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, ByteArray::create("def")), "foo@bar.com/baz", "id-b"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));
+			stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, createByteArray("def")), "foo@bar.com/baz", "id-b"));
 
 			CPPUNIT_ASSERT(stanzaChannel->isResultAtIndex(2, "id-b"));
-			CPPUNIT_ASSERT(ByteArray::create("abcdef") == receivedData);
+			CPPUNIT_ASSERT(createByteArray("abcdef") == receivedData);
 			CPPUNIT_ASSERT(finished);
 			CPPUNIT_ASSERT(!error);
 
diff --git a/Swiften/FileTransfer/UnitTest/IBBSendSessionTest.cpp b/Swiften/FileTransfer/UnitTest/IBBSendSessionTest.cpp
index f84c3bb..558a3d7 100644
--- a/Swiften/FileTransfer/UnitTest/IBBSendSessionTest.cpp
+++ b/Swiften/FileTransfer/UnitTest/IBBSendSessionTest.cpp
@@ -32,7 +32,7 @@ class IBBSendSessionTest : public CppUnit::TestFixture {
 		void setUp() {
 			stanzaChannel = new DummyStanzaChannel();
 			iqRouter = new IQRouter(stanzaChannel);
-			bytestream = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(ByteArray::create("abcdefg")));
+			bytestream = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(createByteArray("abcdefg")));
 		}
 
 		void tearDown() {
@@ -65,7 +65,7 @@ class IBBSendSessionTest : public CppUnit::TestFixture {
 			CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<IBB>(1, JID("foo@bar.com/baz"), IQ::Set));
 			IBB::ref ibb = stanzaChannel->sentStanzas[1]->getPayload<IBB>();
 			CPPUNIT_ASSERT_EQUAL(IBB::Data, ibb->getAction());
-			CPPUNIT_ASSERT(ByteArray::create("abc") == ibb->getData());
+			CPPUNIT_ASSERT(createByteArray("abc") == ibb->getData());
 			CPPUNIT_ASSERT_EQUAL(0, ibb->getSequenceNumber());
 			CPPUNIT_ASSERT_EQUAL(std::string("myid"), ibb->getStreamID());
 		}
@@ -81,7 +81,7 @@ class IBBSendSessionTest : public CppUnit::TestFixture {
 			CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<IBB>(2, JID("foo@bar.com/baz"), IQ::Set));
 			IBB::ref ibb = stanzaChannel->sentStanzas[2]->getPayload<IBB>();
 			CPPUNIT_ASSERT_EQUAL(IBB::Data, ibb->getAction());
-			CPPUNIT_ASSERT(ByteArray::create("def") == ibb->getData());
+			CPPUNIT_ASSERT(createByteArray("def") == ibb->getData());
 			CPPUNIT_ASSERT_EQUAL(1, ibb->getSequenceNumber());
 			CPPUNIT_ASSERT_EQUAL(std::string("myid"), ibb->getStreamID());
 		}
diff --git a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamServerSessionTest.cpp b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamServerSessionTest.cpp
index d1f7000..d4c31c5 100644
--- a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamServerSessionTest.cpp
+++ b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamServerSessionTest.cpp
@@ -10,6 +10,7 @@
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <boost/bind.hpp>
 
+#include <Swiften/Base/Concat.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerSession.h>
 #include <Swiften/FileTransfer/ByteArrayReadBytestream.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>
@@ -35,7 +36,7 @@ class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {
 			eventLoop = new DummyEventLoop();
 			connection = boost::shared_ptr<DummyConnection>(new DummyConnection(eventLoop));
 			connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));
-			stream1 = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(ByteArray::create("abcdefg")));
+			stream1 = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(createByteArray("abcdefg")));
 		}
 
 		void tearDown() {
@@ -47,20 +48,20 @@ class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {
 			boost::shared_ptr<SOCKS5BytestreamServerSession> testling(createSession());
 			StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());
 
-			receive(ByteArray::create("\x05\x02\x01\x02"));
+			receive(createByteArray("\x05\x02\x01\x02"));
 
-			CPPUNIT_ASSERT(ByteArray::create("\x05\x00", 2) == receivedData);
+			CPPUNIT_ASSERT(createByteArray("\x05\x00", 2) == receivedData);
 		}
 
 		void testAuthenticate_Chunked() {
 			boost::shared_ptr<SOCKS5BytestreamServerSession> testling(createSession());
 			StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());
 
-			receive(ByteArray::create("\x05\x02\x01"));
+			receive(createByteArray("\x05\x02\x01"));
 
 			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedData.size()));
-			receive(ByteArray::create("\x01"));
-			CPPUNIT_ASSERT(ByteArray::create("\x05\x00", 2) == receivedData);
+			receive(createByteArray("\x01"));
+			CPPUNIT_ASSERT(createByteArray("\x05\x00", 2) == receivedData);
 		}
 
 		void testRequest() {
@@ -69,9 +70,9 @@ class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {
 			bytestreams.addBytestream("abcdef", stream1);
 			authenticate();
 
-			ByteArray hostname("abcdef");
-			receive(ByteArray(ByteArray::create("\x05\x01\x00\x03", 4)) + hostname.getSize() + hostname + ByteArray::create("\x00\x00", 2));
-			CPPUNIT_ASSERT(ByteArray::create("\x05\x00\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13) == ByteArray::create(&receivedData[0], 13));
+			ByteArray hostname(createByteArray("abcdef"));
+			receive(concat(createByteArray("\x05\x01\x00\x03", 4), createByteArray(hostname.size()), hostname, createByteArray("\x00\x00", 2)));
+			CPPUNIT_ASSERT(createByteArray("\x05\x00\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13) == createByteArray(&receivedData[0], 13));
 		}
 
 		void testRequest_UnknownBytestream() {
@@ -79,9 +80,9 @@ class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {
 			StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());
 			authenticate();
 
-			ByteArray hostname("abcdef");
-			receive(ByteArray(ByteArray::create("\x05\x01\x00\x03", 4)) + hostname.getSize() + hostname + ByteArray::create("\x00\x00", 2));
-			CPPUNIT_ASSERT(ByteArray::create("\x05\x04\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13) == receivedData);
+			ByteArray hostname(createByteArray("abcdef"));
+			receive(concat(createByteArray("\x05\x01\x00\x03", 4), createByteArray(hostname.size()), hostname, createByteArray("\x00\x00", 2)));
+			CPPUNIT_ASSERT(createByteArray("\x05\x04\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13) == receivedData);
 		}
 
 		void testReceiveData() {
@@ -93,7 +94,7 @@ class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {
 			eventLoop->processEvents();
 			skipHeader("abcdef");
 
-			CPPUNIT_ASSERT(ByteArray::create("abcdefg") == receivedData);
+			CPPUNIT_ASSERT(createByteArray("abcdefg") == receivedData);
 			CPPUNIT_ASSERT_EQUAL(2, receivedDataChunks);
 		}
 
@@ -107,7 +108,7 @@ class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {
 			eventLoop->processEvents();
 
 			skipHeader("abcdef");
-			CPPUNIT_ASSERT(ByteArray::create("abcdefg") == receivedData);
+			CPPUNIT_ASSERT(createByteArray("abcdefg") == receivedData);
 			CPPUNIT_ASSERT_EQUAL(4, receivedDataChunks);
 		}
 
@@ -118,18 +119,18 @@ class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {
 		}
 
 		void authenticate() {
-			receive(ByteArray::create("\x05\x02\x01\x02"));
+			receive(createByteArray("\x05\x02\x01\x02"));
 			receivedData.clear();
 			receivedDataChunks = 0;
 		}
 
 		void request(const std::string& hostname) {
-			receive(ByteArray(ByteArray::create("\x05\x01\x00\x03", 4)) + hostname.size() + hostname + ByteArray::create("\x00\x00", 2));
+			receive(concat(createByteArray("\x05\x01\x00\x03", 4), createByteArray(hostname.size()), createByteArray(hostname), createByteArray("\x00\x00", 2)));
 		}
 
 		void skipHeader(const std::string& hostname) {
 			int headerSize = 7 + hostname.size();
-			receivedData = ByteArray::create(&receivedData[headerSize], receivedData.size() - headerSize);
+			receivedData = createByteArray(&receivedData[headerSize], receivedData.size() - headerSize);
 		}
 
 
diff --git a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.h b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.h
index 1109fb7..57fde49 100644
--- a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.h
+++ b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuerier.h
@@ -14,10 +14,9 @@
 
 #include <Swiften/LinkLocal/DNSSD/DNSSDQuerier.h>
 #include <Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
-	class ByteArray;
-
 	class BonjourQuerier : 
 			public DNSSDQuerier, 
 			public boost::enable_shared_from_this<BonjourQuerier> {
diff --git a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourRegisterQuery.h b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourRegisterQuery.h
index b31e441..fd0e9d0 100644
--- a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourRegisterQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourRegisterQuery.h
@@ -19,7 +19,7 @@ namespace Swift {
 			BonjourRegisterQuery(const std::string& name, int port, const ByteArray& txtRecord, boost::shared_ptr<BonjourQuerier> querier, EventLoop* eventLoop) : BonjourQuery(querier, eventLoop) {
 				DNSServiceErrorType result = DNSServiceRegister(
 						&sdRef, 0, 0, name.c_str(), "_presence._tcp", NULL, NULL, port, 
-						txtRecord.getSize(), txtRecord.getData(), 
+						txtRecord.size(), vecptr(txtRecord), 
 						&BonjourRegisterQuery::handleServiceRegisteredStatic, this);
 				if (result != kDNSServiceErr_NoError) {
 					sdRef = NULL;
@@ -41,7 +41,7 @@ namespace Swift {
 
 			void updateServiceInfo(const ByteArray& txtRecord) {
 				boost::lock_guard<boost::mutex> lock(sdRefMutex);
-				DNSServiceUpdateRecord(sdRef, NULL, NULL, txtRecord.getSize(), txtRecord.getData(), 0);
+				DNSServiceUpdateRecord(sdRef, NULL, NULL, txtRecord.size(), vecptr(txtRecord), 0);
 			}
 
 		private:
diff --git a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveServiceQuery.h b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveServiceQuery.h
index 2d40e72..1fb050c 100644
--- a/Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveServiceQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Bonjour/BonjourResolveServiceQuery.h
@@ -56,7 +56,7 @@ namespace Swift {
 							boost::bind(
 								boost::ref(onServiceResolved), 
 								Result(std::string(fullName), std::string(host), port, 
-									ByteArray(reinterpret_cast<const char*>(txtRecord), txtLen))), 
+									createByteArray(reinterpret_cast<const char*>(txtRecord), txtLen))), 
 							shared_from_this());
 				}
 			}
diff --git a/Swiften/LinkLocal/DNSSD/DNSSDQuerier.h b/Swiften/LinkLocal/DNSSD/DNSSDQuerier.h
index cd55fb7..e6d548b 100644
--- a/Swiften/LinkLocal/DNSSD/DNSSDQuerier.h
+++ b/Swiften/LinkLocal/DNSSD/DNSSDQuerier.h
@@ -8,9 +8,9 @@
 
 #include <boost/shared_ptr.hpp>
 
+#include <Swiften/Base/ByteArray.h>
+
 namespace Swift {
-	
-	class ByteArray;
 	class DNSSDServiceID;
 	class DNSSDBrowseQuery;
 	class DNSSDRegisterQuery;
diff --git a/Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h b/Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h
index 93555c2..e794a90 100644
--- a/Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h
+++ b/Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h
@@ -10,10 +10,9 @@
 #include <boost/optional.hpp>
 
 #include <Swiften/LinkLocal/DNSSD/DNSSDServiceID.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
-	class ByteArray;
-
 	class DNSSDRegisterQuery {
 		public:
 			virtual ~DNSSDRegisterQuery();
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
index 97a2c6e..f5166ee 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
@@ -12,13 +12,13 @@
 #include <set>
 
 #include <string>
+#include <Swiften/Base/ByteArray.h>
 #include <Swiften/EventLoop/EventOwner.h>
 #include <Swiften/LinkLocal/DNSSD/DNSSDQuerier.h>
 #include <Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h>
 #include <Swiften/Network/HostAddress.h>
 
 namespace Swift {
-	class ByteArray;
 	class FakeDNSSDQuery;
 	class FakeDNSSDBrowseQuery;
 	class EventLoop;
diff --git a/Swiften/LinkLocal/LinkLocalServiceInfo.cpp b/Swiften/LinkLocal/LinkLocalServiceInfo.cpp
index 2be0049..f437fc2 100644
--- a/Swiften/LinkLocal/LinkLocalServiceInfo.cpp
+++ b/Swiften/LinkLocal/LinkLocalServiceInfo.cpp
@@ -8,36 +8,39 @@
 
 #include <boost/lexical_cast.hpp>
 
+#include <Swiften/Base/Algorithm.h>
+#include <Swiften/Base/Concat.h>
+
 namespace Swift {
 
 ByteArray LinkLocalServiceInfo::toTXTRecord() const {
 	ByteArray result(getEncoded("txtvers=1"));
 	if (!firstName.empty()) {
-		result += getEncoded("1st=" + firstName);
+		append(result, getEncoded("1st=" + firstName));
 	}
 	if (!lastName.empty()) {
-		result += getEncoded("last=" + lastName);
+		append(result, getEncoded("last=" + lastName));
 	}
 	if (!email.empty()) {
-		result += getEncoded("email=" + email);
+		append(result, getEncoded("email=" + email));
 	}
 	if (jid.isValid()) {
-		result += getEncoded("jid=" + jid.toString());
+		append(result, getEncoded("jid=" + jid.toString()));
 	}
 	if (!message.empty()) {
-		result += getEncoded("msg=" + message);
+		append(result, getEncoded("msg=" + message));
 	}
 	if (!nick.empty()) {
-		result += getEncoded("nick=" + nick);
+		append(result, getEncoded("nick=" + nick));
 	}
 	if (port) {
-		result += getEncoded("port.p2pj=" + std::string(boost::lexical_cast<std::string>(*port)));
+		append(result, getEncoded("port.p2pj=" + std::string(boost::lexical_cast<std::string>(*port))));
 	}
 
 	switch (status) {
-		case Available: result += getEncoded("status=avail"); break;
-		case Away: result += getEncoded("status=away"); break;
-		case DND: result += getEncoded("status=dnd"); break;
+		case Available: append(result, getEncoded("status=avail")); break;
+		case Away: append(result, getEncoded("status=away")); break;
+		case DND: append(result, getEncoded("status=dnd")); break;
 	}
 
 	return result;
@@ -47,13 +50,13 @@ ByteArray LinkLocalServiceInfo::getEncoded(const std::string& s) {
 	ByteArray sizeByte;
 	sizeByte.resize(1);
 	sizeByte[0] = s.size();
-	return sizeByte + ByteArray(s);
+	return concat(sizeByte, createByteArray(s));
 }
 
 LinkLocalServiceInfo LinkLocalServiceInfo::createFromTXTRecord(const ByteArray& record) {
 	LinkLocalServiceInfo info;
 	size_t i = 0;
-	while (i < record.getSize()) {
+	while (i < record.size()) {
 		std::pair<std::string,std::string> entry = readEntry(record, &i);
 		if (entry.first.empty()) {
 			break;
@@ -99,7 +102,7 @@ std::pair<std::string,std::string> LinkLocalServiceInfo::readEntry(const ByteArr
 	size_t entryEnd = i + 1 + record[i];
 	++i;
 	bool inKey = true;
-	while (i < entryEnd && i < record.getSize()) {
+	while (i < entryEnd && i < record.size()) {
 		if (inKey) {
 			if (record[i] == '=') {
 				inKey = false;
diff --git a/Swiften/LinkLocal/UnitTest/LinkLocalServiceInfoTest.cpp b/Swiften/LinkLocal/UnitTest/LinkLocalServiceInfoTest.cpp
index 1e69cd0..bce7331 100644
--- a/Swiften/LinkLocal/UnitTest/LinkLocalServiceInfoTest.cpp
+++ b/Swiften/LinkLocal/UnitTest/LinkLocalServiceInfoTest.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/LinkLocal/LinkLocalServiceInfo.h>
 
 using namespace Swift;
@@ -28,11 +29,11 @@ class LinkLocalServiceInfoTest : public CppUnit::TestFixture {
 			info.setLastName("Tron\xc3\xe7on");
 			info.setStatus(LinkLocalServiceInfo::Away);
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x09txtvers=1\x09" + std::string("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")), info.toTXTRecord());
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x09txtvers=1\x09" + std::string("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")), info.toTXTRecord());
 		}
 
 		void testCreateFromTXTRecord() {
-			LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(ByteArray("\x09txtvers=1\x09" + std::string("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")));
+			LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(createByteArray("\x09txtvers=1\x09" + std::string("1st=Remko\x0dlast=Tron\xc3\xe7on\x0bstatus=away")));
 
 			CPPUNIT_ASSERT_EQUAL(std::string("Remko"), info.getFirstName());
 			CPPUNIT_ASSERT_EQUAL(std::string("Tron\xc3\xe7on"), info.getLastName());
@@ -40,7 +41,7 @@ class LinkLocalServiceInfoTest : public CppUnit::TestFixture {
 		}
 
 		void testCreateFromTXTRecord_InvalidSize() {
-			LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(ByteArray("\x10last=a"));
+			LinkLocalServiceInfo info = LinkLocalServiceInfo::createFromTXTRecord(createByteArray("\x10last=a"));
 
 			CPPUNIT_ASSERT_EQUAL(std::string("a"), info.getLastName());
 		}
diff --git a/Swiften/Network/BoostConnection.cpp b/Swiften/Network/BoostConnection.cpp
index 2fdb468..b56ad38 100644
--- a/Swiften/Network/BoostConnection.cpp
+++ b/Swiften/Network/BoostConnection.cpp
@@ -7,14 +7,15 @@
 #include <Swiften/Network/BoostConnection.h>
 
 #include <iostream>
+#include <string>
 #include <boost/bind.hpp>
 #include <boost/thread.hpp>
 #include <boost/asio/placeholders.hpp>
 #include <boost/asio/write.hpp>
 
 #include <Swiften/Base/Log.h>
+#include <Swiften/Base/Algorithm.h>
 #include <Swiften/EventLoop/EventLoop.h>
-#include <string>
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/Network/HostAddressPort.h>
 #include <Swiften/Base/sleep.h>
@@ -84,7 +85,7 @@ void BoostConnection::write(const ByteArray& data) {
 		doWrite(data);
 	}
 	else {
-		writeQueue_ += data;
+		append(writeQueue_, data);
 	}
 }
 
@@ -113,7 +114,7 @@ void BoostConnection::doRead() {
 void BoostConnection::handleSocketRead(const boost::system::error_code& error, size_t bytesTransferred) {
 	SWIFT_LOG(debug) << "Socket read " << error << std::endl;
 	if (!error) {
-		eventLoop->postEvent(boost::bind(boost::ref(onDataRead), ByteArray(&readBuffer_[0], bytesTransferred)), shared_from_this());
+		eventLoop->postEvent(boost::bind(boost::ref(onDataRead), createByteArray(&readBuffer_[0], bytesTransferred)), shared_from_this());
 		doRead();
 	}
 	else if (/*error == boost::asio::error::eof ||*/ error == boost::asio::error::operation_aborted) {
@@ -137,7 +138,7 @@ void BoostConnection::handleDataWritten(const boost::system::error_code& error)
 	}
 	{
 		boost::lock_guard<boost::mutex> lock(writeMutex_);
-		if (writeQueue_.isEmpty()) {
+		if (writeQueue_.empty()) {
 			writing_ = false;
 		}
 		else {
diff --git a/Swiften/Network/HTTPConnectProxiedConnection.cpp b/Swiften/Network/HTTPConnectProxiedConnection.cpp
index dca08df..61fe597 100644
--- a/Swiften/Network/HTTPConnectProxiedConnection.cpp
+++ b/Swiften/Network/HTTPConnectProxiedConnection.cpp
@@ -66,7 +66,7 @@ void HTTPConnectProxiedConnection::handleConnectionConnectFinished(bool error) {
 	if (!error) {
 		std::stringstream connect;
 		connect << "CONNECT " << server_.getAddress().toString() << ":" << server_.getPort() << " HTTP/1.1\r\n\r\n";
-		connection_->write(ByteArray(connect.str()));
+		connection_->write(createByteArray(connect.str()));
 	}
 	else {
 		onConnectFinished(true);
@@ -75,8 +75,8 @@ void HTTPConnectProxiedConnection::handleConnectionConnectFinished(bool error) {
 
 void HTTPConnectProxiedConnection::handleDataRead(const ByteArray& data) {
 	if (!connected_) {
-		SWIFT_LOG(debug) << data.toString() << std::endl;
-		std::vector<std::string> tmp = String::split(data.toString(), ' ');
+		SWIFT_LOG(debug) << byteArrayToString(data) << std::endl;
+		std::vector<std::string> tmp = String::split(byteArrayToString(data), ' ');
 		if(tmp.size() > 1) {
 			int status = boost::lexical_cast<int> (tmp[1].c_str()); 
 			SWIFT_LOG(debug) << "Proxy Status: " << status << std::endl;
@@ -85,7 +85,7 @@ void HTTPConnectProxiedConnection::handleDataRead(const ByteArray& data) {
 				onConnectFinished(false);
 				return;
 			}
-			SWIFT_LOG(debug) << "HTTP Proxy returned an error: " << data.toString() << std::endl;
+			SWIFT_LOG(debug) << "HTTP Proxy returned an error: " << byteArrayToString(data) << std::endl;
 		}
 		disconnect();
 		onConnectFinished(true);
diff --git a/Swiften/Network/PlatformDomainNameServiceQuery.cpp b/Swiften/Network/PlatformDomainNameServiceQuery.cpp
index 56c9748..5d076ac 100644
--- a/Swiften/Network/PlatformDomainNameServiceQuery.cpp
+++ b/Swiften/Network/PlatformDomainNameServiceQuery.cpp
@@ -81,7 +81,7 @@ void PlatformDomainNameServiceQuery::runBlocking() {
 
 	ByteArray response;
 	response.resize(NS_PACKETSZ);
-	int responseLength = res_query(const_cast<char*>(service.c_str()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(response.getData()), response.getSize());
+	int responseLength = res_query(const_cast<char*>(service.c_str()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(vecptr(response)), response.size());
 	if (responseLength == -1) {
 		SWIFT_LOG(debug) << "Error" << std::endl;
 		emitError();
@@ -89,8 +89,8 @@ void PlatformDomainNameServiceQuery::runBlocking() {
 	}
 
 	// Parse header
-	HEADER* header = reinterpret_cast<HEADER*>(response.getData());
-	unsigned char* messageStart = reinterpret_cast<unsigned char*>(response.getData());
+	HEADER* header = reinterpret_cast<HEADER*>(vecptr(response));
+	unsigned char* messageStart = vecptr(response);
 	unsigned char* messageEnd = messageStart + responseLength;
 	unsigned char* currentEntry = messageStart + NS_HFIXEDSZ;
 
@@ -146,12 +146,12 @@ void PlatformDomainNameServiceQuery::runBlocking() {
 		}
 		ByteArray entry;
 		entry.resize(NS_MAXDNAME);
-		entryLength = dn_expand(messageStart, messageEnd, currentEntry, reinterpret_cast<char*>(entry.getData()), entry.getSize());
+		entryLength = dn_expand(messageStart, messageEnd, currentEntry, reinterpret_cast<char*>(vecptr(entry)), entry.size());
 		if (entryLength < 0) {
 			emitError();
 			return;
 		}
-		record.hostname = std::string(reinterpret_cast<const char*>(entry.getData()));
+		record.hostname = std::string(reinterpret_cast<const char*>(vecptr(entry)));
 		records.push_back(record);
 		currentEntry += entryLength;
 		answersCount--;
diff --git a/Swiften/Network/SOCKS5ProxiedConnection.cpp b/Swiften/Network/SOCKS5ProxiedConnection.cpp
index 52e56a9..cf531e5 100644
--- a/Swiften/Network/SOCKS5ProxiedConnection.cpp
+++ b/Swiften/Network/SOCKS5ProxiedConnection.cpp
@@ -73,9 +73,9 @@ void SOCKS5ProxiedConnection::handleConnectionConnectFinished(bool error) {
 		
 		proxyState_ = ProxyAuthenticating;
 		ByteArray socksConnect;
-		socksConnect += 0x05; // VER = SOCKS5 = 0x05
-		socksConnect += 0x01; // Number of authentication methods after this byte.
-		socksConnect += 0x00; // 0x00 == no authentication
+		socksConnect.push_back(0x05); // VER = SOCKS5 = 0x05
+		socksConnect.push_back(0x01); // Number of authentication methods after this byte.
+		socksConnect.push_back(0x00); // 0x00 == no authentication
 		// buffer.push_back(0x01); // 0x01 == GSSAPI 
 		// buffer.push_back(0x02); // 0x02 ==  Username/Password
 		// rest see RFC 1928 (http://tools.ietf.org/html/rfc1928)
@@ -99,10 +99,10 @@ void SOCKS5ProxiedConnection::handleDataRead(const ByteArray& data) {
 					case 0x00:
 						try {
 							proxyState_ = ProxyConnecting;
-							socksConnect += 0x05; // VER = SOCKS5 = 0x05
-							socksConnect += 0x01; // Construct a TCP connection. (CMD)
-							socksConnect += 0x00; // reserved.
-							socksConnect += rawAddress.is_v4() ? 0x01 : 0x04; // IPv4 == 0x01, Hostname == 0x02, IPv6 == 0x04. (ATYP)
+							socksConnect.push_back(0x05); // VER = SOCKS5 = 0x05
+							socksConnect.push_back(0x01); // Construct a TCP connection. (CMD)
+							socksConnect.push_back(0x00); // reserved.
+							socksConnect.push_back(rawAddress.is_v4() ? 0x01 : 0x04); // IPv4 == 0x01, Hostname == 0x02, IPv6 == 0x04. (ATYP)
 							size_t size = rawAddress.is_v4() ? rawAddress.to_v4().to_bytes().size() : rawAddress.to_v6().to_bytes().size();
 							for (size_t s = 0; s < size; s++) {
 								unsigned char uc;
@@ -112,11 +112,11 @@ void SOCKS5ProxiedConnection::handleDataRead(const ByteArray& data) {
 								else {
 									uc = rawAddress.to_v6().to_bytes()[s]; // the address.
 								}
-								socksConnect += static_cast<char> (uc);
+								socksConnect.push_back(static_cast<char>(uc));
 						
 							}
-							socksConnect += static_cast<unsigned char> ((server_.getPort() >> 8) & 0xFF); // highbyte of the port.
-							socksConnect += static_cast<unsigned char> (server_.getPort() & 0xFF); // lowbyte of the port.
+							socksConnect.push_back(static_cast<unsigned char> ((server_.getPort() >> 8) & 0xFF)); // highbyte of the port.
+							socksConnect.push_back(static_cast<unsigned char> (server_.getPort() & 0xFF)); // lowbyte of the port.
 							connection_->write(socksConnect);
 							return;
 						}
diff --git a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
index 6c4c89c..d33c988 100644
--- a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
+++ b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
@@ -12,6 +12,8 @@
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 
+#include <QA/Checker/IO.h>
+#include <Swiften/Base/Algorithm.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/HTTPConnectProxiedConnection.h>
@@ -66,7 +68,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			eventLoop->processEvents();
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n\r\n"), connectionFactory->connections[0]->dataWritten);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n\r\n"), connectionFactory->connections[0]->dataWritten);
 		}
 
 		void testConnect_ReceiveConnectResponse() {
@@ -74,12 +76,12 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			eventLoop->processEvents();
 
-			connectionFactory->connections[0]->onDataRead(ByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
+			connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
 
 			CPPUNIT_ASSERT(connectFinished);
 			CPPUNIT_ASSERT(!connectFinishedWithError);
-			CPPUNIT_ASSERT(dataRead.isEmpty());
+			CPPUNIT_ASSERT(dataRead.empty());
 		}
 
 		void testConnect_ReceiveMalformedConnectResponse() {
@@ -87,7 +89,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			eventLoop->processEvents();
 
-			connectionFactory->connections[0]->onDataRead(ByteArray("FLOOP"));
+			connectionFactory->connections[0]->onDataRead(createByteArray("FLOOP"));
 			eventLoop->processEvents();
 
 			CPPUNIT_ASSERT(connectFinished);
@@ -100,7 +102,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			eventLoop->processEvents();
 
-			connectionFactory->connections[0]->onDataRead(ByteArray("HTTP/1.0 401 Unauthorized\r\n\r\n"));
+			connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 401 Unauthorized\r\n\r\n"));
 			eventLoop->processEvents();
 
 			CPPUNIT_ASSERT(connectFinished);
@@ -112,25 +114,25 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
 			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			eventLoop->processEvents();
-			connectionFactory->connections[0]->onDataRead(ByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
+			connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
 
-			connectionFactory->connections[0]->onDataRead(ByteArray("abcdef"));
+			connectionFactory->connections[0]->onDataRead(createByteArray("abcdef"));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("abcdef"), dataRead);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), dataRead);
 		}
 
 		void testWrite_AfterConnect() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
 			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			eventLoop->processEvents();
-			connectionFactory->connections[0]->onDataRead(ByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
+			connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
 			connectionFactory->connections[0]->dataWritten.clear();
 
-			testling->write(ByteArray("abcdef"));
+			testling->write(createByteArray("abcdef"));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("abcdef"), connectionFactory->connections[0]->dataWritten);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("abcdef"), connectionFactory->connections[0]->dataWritten);
 		}
 
 		void testDisconnect_AfterConnectRequest() {
@@ -149,7 +151,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
 			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			eventLoop->processEvents();
-			connectionFactory->connections[0]->onDataRead(ByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
+			connectionFactory->connections[0]->onDataRead(createByteArray("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
 
 			testling->disconnect();
@@ -179,7 +181,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 		}
 
 		void handleDataRead(const ByteArray& d) {
-			dataRead += d;
+			append(dataRead, d);
 		}
 
 		struct MockConnection : public Connection {
@@ -203,7 +205,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 				}
 				
 				void write(const ByteArray& d) { 
-					dataWritten += d;
+					append(dataWritten, d);
 				}
 
 				EventLoop* eventLoop;
diff --git a/Swiften/Network/WindowsProxyProvider.cpp b/Swiften/Network/WindowsProxyProvider.cpp
index 5fb3c3a..3ae43e0 100644
--- a/Swiften/Network/WindowsProxyProvider.cpp
+++ b/Swiften/Network/WindowsProxyProvider.cpp
@@ -36,9 +36,9 @@ WindowsProxyProvider::WindowsProxyProvider()
 			return;
 		}
 		dataBuffer.resize(dataSize);
-		result = RegQueryValueEx(hKey, "ProxyServer", NULL, &dataType, reinterpret_cast<BYTE*>(dataBuffer.getData()), &dataSize);
+		result = RegQueryValueEx(hKey, "ProxyServer", NULL, &dataType, reinterpret_cast<BYTE*>(vecptr(dataBuffer)), &dataSize);
 		if(result == ERROR_SUCCESS) {
-			std::vector<std::string> proxies = String::split(dataBuffer.toString(), ';');
+			std::vector<std::string> proxies = String::split(byteArrayToString(dataBuffer), ';');
 			std::pair<std::string, std::string> protocolAndProxy;
 			foreach(std::string proxy, proxies) {
 				if(proxy.find('=') != std::string::npos) {
@@ -100,11 +100,11 @@ bool WindowsProxyProvider::proxyEnabled(HKEY hKey) const {
 		return ret;
 
 	dataBuffer.resize(dataSize);
-	result = RegQueryValueEx(hKey, "ProxyEnable", NULL, &dataType, reinterpret_cast<BYTE*>(dataBuffer.getData()), &dataSize);
+	result = RegQueryValueEx(hKey, "ProxyEnable", NULL, &dataType, reinterpret_cast<BYTE*>(vecptr(dataBuffer)), &dataSize);
 	if(result != ERROR_SUCCESS)
 		return ret;
 
-	for(size_t t = 0; t < dataBuffer.getSize(); t++) {
+	for(size_t t = 0; t < dataBuffer.size(); t++) {
 		data += static_cast<int> (dataBuffer[t]) * pow(256, static_cast<double>(t));
 	}
 	return (data == 1);
diff --git a/Swiften/Parser/PayloadParsers/IBBParser.cpp b/Swiften/Parser/PayloadParsers/IBBParser.cpp
index 2505f07..2705c75 100644
--- a/Swiften/Parser/PayloadParsers/IBBParser.cpp
+++ b/Swiften/Parser/PayloadParsers/IBBParser.cpp
@@ -64,7 +64,7 @@ void IBBParser::handleEndElement(const std::string& element, const std::string&)
 					data.push_back(c);
 				}
 			}
-			getPayloadInternal()->setData(Base64::decode(std::string(&data[0], data.size())).getDataVector());
+			getPayloadInternal()->setData(Base64::decode(std::string(&data[0], data.size())));
 		}
 	}
 }
diff --git a/Swiften/Parser/PayloadParsers/UnitTest/IBBParserTest.cpp b/Swiften/Parser/PayloadParsers/UnitTest/IBBParserTest.cpp
index 774ded3..90d7b6b 100644
--- a/Swiften/Parser/PayloadParsers/UnitTest/IBBParserTest.cpp
+++ b/Swiften/Parser/PayloadParsers/UnitTest/IBBParserTest.cpp
@@ -32,7 +32,7 @@ class IBBParserTest : public CppUnit::TestFixture {
 
 			IBB::ref ibb = parser.getPayload<IBB>();
 			CPPUNIT_ASSERT(ibb->getAction() == IBB::Data);
-			CPPUNIT_ASSERT(ByteArray::create("abcdefgihjklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890\x0a") == ibb->getData());
+			CPPUNIT_ASSERT(createByteArray("abcdefgihjklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890\x0a") == ibb->getData());
 			CPPUNIT_ASSERT_EQUAL(4, ibb->getSequenceNumber());
 		}
 };
diff --git a/Swiften/Parser/PayloadParsers/UnitTest/VCardParserTest.cpp b/Swiften/Parser/PayloadParsers/UnitTest/VCardParserTest.cpp
index f0fca3c..fd79b40 100644
--- a/Swiften/Parser/PayloadParsers/UnitTest/VCardParserTest.cpp
+++ b/Swiften/Parser/PayloadParsers/UnitTest/VCardParserTest.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Parser/PayloadParsers/VCardParser.h>
 #include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>
 
@@ -93,7 +94,7 @@ class VCardParserTest : public CppUnit::TestFixture {
 
 			VCard* payload = dynamic_cast<VCard*>(parser.getPayload().get());
 			CPPUNIT_ASSERT_EQUAL(std::string("image/jpeg"), payload->getPhotoType());
-			CPPUNIT_ASSERT_EQUAL(ByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), payload->getPhoto());
+			CPPUNIT_ASSERT_EQUAL(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), payload->getPhoto());
 		}
 
 		void testParse_Nickname() {
diff --git a/Swiften/QA/NetworkTest/BoostConnectionTest.cpp b/Swiften/QA/NetworkTest/BoostConnectionTest.cpp
index 0929974..3d3c3c4 100644
--- a/Swiften/QA/NetworkTest/BoostConnectionTest.cpp
+++ b/Swiften/QA/NetworkTest/BoostConnectionTest.cpp
@@ -10,6 +10,7 @@
 #include <boost/smart_ptr/make_shared.hpp>
 
 #include <string>
+#include <Swiften/Base/Algorithm.h>
 #include <Swiften/Base/sleep.h>
 #include <Swiften/Network/BoostConnection.h>
 #include <Swiften/Network/HostAddress.h>
@@ -70,7 +71,7 @@ class BoostConnectionTest : public CppUnit::TestFixture {
 			testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));
 			testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));
 			testling->connect(HostAddressPort(HostAddress("65.99.222.137"), 5222));
-			while (receivedData.isEmpty()) {
+			while (receivedData.empty()) {
 				Swift::sleep(10);
 				eventLoop_->processEvents();
 			}
@@ -83,7 +84,7 @@ class BoostConnectionTest : public CppUnit::TestFixture {
 			testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));
 			testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));
 			testling->connect(HostAddressPort(HostAddress("2001:470:1f0e:852::2"), 80));
-			while (receivedData.isEmpty()) {
+			while (receivedData.empty()) {
 				Swift::sleep(10);
 				eventLoop_->processEvents();
 			}
@@ -102,9 +103,9 @@ class BoostConnectionTest : public CppUnit::TestFixture {
 				eventLoop_->processEvents();
 			}
 
-			testling->write(ByteArray("<stream:strea"));
-			testling->write(ByteArray("m"));
-			testling->write(ByteArray(">"));
+			testling->write(createByteArray("<stream:strea"));
+			testling->write(createByteArray("m"));
+			testling->write(createByteArray(">"));
 
 			 // Check that we only did one write event, the others are queued
 			/*int runHandlers = */boostIOService->poll();
@@ -112,7 +113,7 @@ class BoostConnectionTest : public CppUnit::TestFixture {
 			// this test doesn't really work any more. We'll have to trust that things are queued.
 			//CPPUNIT_ASSERT_EQUAL(1, runHandlers);
 			// Process the other events
-			while (receivedData.isEmpty()) {
+			while (receivedData.empty()) {
 				boostIOService->run_one();
 				eventLoop_->processEvents();
 			}
@@ -126,12 +127,12 @@ class BoostConnectionTest : public CppUnit::TestFixture {
 		}
 
 		void doWrite(BoostConnection* connection) {
-			connection->write(ByteArray("<stream:stream>"));
-			connection->write(ByteArray("\r\n\r\n")); // Temporarily, while we don't have an xmpp server running on ipv6
+			connection->write(createByteArray("<stream:stream>"));
+			connection->write(createByteArray("\r\n\r\n")); // Temporarily, while we don't have an xmpp server running on ipv6
 		}
 
 		void handleDataRead(const ByteArray& data) {
-			receivedData += data;
+			append(receivedData, data);
 		}
 
 		void handleDisconnected() {
diff --git a/Swiften/QA/TLSTest/CertificateTest.cpp b/Swiften/QA/TLSTest/CertificateTest.cpp
index dff065f..67ca064 100644
--- a/Swiften/QA/TLSTest/CertificateTest.cpp
+++ b/Swiften/QA/TLSTest/CertificateTest.cpp
@@ -10,6 +10,7 @@
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <boost/bind.hpp>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/TLS/CertificateFactory.h>
 #include "SwifTools/Application/PlatformApplicationPathProvider.h"
 
@@ -30,7 +31,7 @@ class CertificateTest : public CppUnit::TestFixture {
 	public:
 		void setUp() {
 			pathProvider = new PlatformApplicationPathProvider("FileReadBytestreamTest");
-			certificateData.readFromFile((pathProvider->getExecutableDir() / "jabber_org.crt").string());
+			readByteArrayFromFile(certificateData, (pathProvider->getExecutableDir() / "jabber_org.crt").string());
 			certificateFactory = new CERTIFICATE_FACTORY();
 		}
 
diff --git a/Swiften/SASL/ClientAuthenticator.h b/Swiften/SASL/ClientAuthenticator.h
index b99d947..399a9d5 100644
--- a/Swiften/SASL/ClientAuthenticator.h
+++ b/Swiften/SASL/ClientAuthenticator.h
@@ -9,7 +9,7 @@
 #include <boost/optional.hpp>
 
 #include <string>
-#include <Swiften/Base/ByteArray.h>
+#include <vector>
 
 namespace Swift {
 	class ClientAuthenticator {
@@ -27,8 +27,8 @@ namespace Swift {
 				this->authzid = authzid;
 			}
 
-			virtual boost::optional<ByteArray> getResponse() const = 0;
-			virtual bool setChallenge(const boost::optional<ByteArray>&) = 0;
+			virtual boost::optional< std::vector<unsigned char> > getResponse() const = 0;
+			virtual bool setChallenge(const boost::optional< std::vector<unsigned char> >&) = 0;
 
 			const std::string& getAuthenticationID() const {
 				return authcid;
diff --git a/Swiften/SASL/DIGESTMD5ClientAuthenticator.cpp b/Swiften/SASL/DIGESTMD5ClientAuthenticator.cpp
index 853609f..3ff0893 100644
--- a/Swiften/SASL/DIGESTMD5ClientAuthenticator.cpp
+++ b/Swiften/SASL/DIGESTMD5ClientAuthenticator.cpp
@@ -10,6 +10,8 @@
 
 #include <Swiften/StringCodecs/MD5.h>
 #include <Swiften/StringCodecs/Hexify.h>
+#include <Swiften/Base/Concat.h>
+#include <Swiften/Base/Algorithm.h>
 
 namespace Swift {
 
@@ -30,16 +32,18 @@ boost::optional<ByteArray> DIGESTMD5ClientAuthenticator::getResponse() const {
 		std::string nc = "00000001";
 
 		// Compute the response value
-		ByteArray A1 = MD5::getHash(getAuthenticationID() + ":" + realm + ":" + getPassword()) + ":" + *challenge.getValue("nonce") + ":" + cnonce;
+		ByteArray A1 = concat(
+			MD5::getHash(createByteArray(getAuthenticationID() + ":" + realm + ":" + getPassword())), createByteArray(":"), createByteArray(*challenge.getValue("nonce")), createByteArray(":"), createByteArray(cnonce));
 		if (!getAuthorizationID().empty()) {
-			A1 += ":" + getAuthenticationID();
+			append(A1, createByteArray(":" + getAuthenticationID()));
 		}
-		std::string A2 = "AUTHENTICATE:" + digestURI;
+		ByteArray A2 = createByteArray("AUTHENTICATE:" + digestURI);
+
+		std::string responseValue = Hexify::hexify(MD5::getHash(createByteArray(
+			Hexify::hexify(MD5::getHash(A1)) + ":"
+			+ *challenge.getValue("nonce") + ":" + nc + ":" + cnonce + ":" + qop + ":"
+			+ Hexify::hexify(MD5::getHash(A2)))));
 
-		std::string responseValue = Hexify::hexify(MD5::getHash(
-				Hexify::hexify(MD5::getHash(A1)) + ":" 
-				+ *challenge.getValue("nonce") + ":" + nc + ":" + cnonce + ":" + qop + ":" 
-				+ Hexify::hexify(MD5::getHash(A2))));
 
 		DIGESTMD5Properties response;
 		response.setValue("username", getAuthenticationID());
diff --git a/Swiften/SASL/DIGESTMD5ClientAuthenticator.h b/Swiften/SASL/DIGESTMD5ClientAuthenticator.h
index f887b37..82c8bc5 100644
--- a/Swiften/SASL/DIGESTMD5ClientAuthenticator.h
+++ b/Swiften/SASL/DIGESTMD5ClientAuthenticator.h
@@ -9,7 +9,7 @@
 #include <map>
 
 #include <string>
-#include <Swiften/Base/ByteArray.h>
+#include <vector>
 #include <Swiften/SASL/ClientAuthenticator.h>
 #include <Swiften/SASL/DIGESTMD5Properties.h>
 
@@ -18,8 +18,8 @@ namespace Swift {
 		public:
 			DIGESTMD5ClientAuthenticator(const std::string& host, const std::string& nonce);
 			
-			virtual boost::optional<ByteArray> getResponse() const;
-			virtual bool setChallenge(const boost::optional<ByteArray>&);
+			virtual boost::optional<std::vector<unsigned char> > getResponse() const;
+			virtual bool setChallenge(const boost::optional<std::vector<unsigned char> >&);
 
 		private:
 			enum Step {
diff --git a/Swiften/SASL/DIGESTMD5Properties.cpp b/Swiften/SASL/DIGESTMD5Properties.cpp
index c9d0882..9eb2680 100644
--- a/Swiften/SASL/DIGESTMD5Properties.cpp
+++ b/Swiften/SASL/DIGESTMD5Properties.cpp
@@ -5,19 +5,20 @@
  */
 
 #include <Swiften/SASL/DIGESTMD5Properties.h>
+#include <Swiften/Base/Algorithm.h>
 
 namespace Swift {
 
 namespace {
 	bool insideQuotes(const ByteArray& v) {
-		if (v.getSize() == 0) {
+		if (v.size() == 0) {
 			return false;
 		}
-		else if (v.getSize() == 1) {
+		else if (v.size() == 1) {
 			return v[0] == '"';
 		}
 		else if (v[0] == '"') {
-			return v[v.getSize() - 1] != '"';
+			return v[v.size() - 1] != '"';
 		}
 		else {
 			return false;
@@ -25,16 +26,16 @@ namespace {
 	}
 
 	ByteArray stripQuotes(const ByteArray& v) {
-		const char* data = reinterpret_cast<const char*>(v.getData());
-		size_t size = v.getSize();
+		const char* data = reinterpret_cast<const char*>(vecptr(v));
+		size_t size = v.size();
 		if (v[0] == '"') {
 			data++;
 			size--;
 		}
-		if (v[v.getSize() - 1] == '"') {
+		if (v[v.size() - 1] == '"') {
 			size--;
 		}
-		return ByteArray(data, size);
+		return createByteArray(data, size);
 	}
 }
 
@@ -46,42 +47,42 @@ DIGESTMD5Properties DIGESTMD5Properties::parse(const ByteArray& data) {
 	bool inKey = true;
 	ByteArray currentKey;
 	ByteArray currentValue;
-	for (size_t i = 0; i < data.getSize(); ++i) {
+	for (size_t i = 0; i < data.size(); ++i) {
 		char c = data[i];
 		if (inKey) {
 			if (c == '=') {
 				inKey = false;
 			}
 			else {
-				currentKey += c;
+				currentKey.push_back(c);
 			}
 		}
 		else {
 			if (c == ',' && !insideQuotes(currentValue)) {
-				std::string key = currentKey.toString();
+				std::string key = byteArrayToString(currentKey);
 				if (isQuoted(key)) {
-					result.setValue(key, stripQuotes(currentValue).toString());
+					result.setValue(key, byteArrayToString(stripQuotes(currentValue)));
 				}
 				else {
-					result.setValue(key, currentValue.toString());
+					result.setValue(key, byteArrayToString(currentValue));
 				}
 				inKey = true;
 				currentKey = ByteArray();
 				currentValue = ByteArray();
 			}
 			else {
-				currentValue += c;
+				currentValue.push_back(c);
 			}
 		}
 	}
 
-	if (!currentKey.isEmpty()) {
-		std::string key = currentKey.toString();
+	if (!currentKey.empty()) {
+		std::string key = byteArrayToString(currentKey);
 		if (isQuoted(key)) {
-			result.setValue(key, stripQuotes(currentValue).toString());
+			result.setValue(key, byteArrayToString(stripQuotes(currentValue)));
 		}
 		else {
-			result.setValue(key, currentValue.toString());
+			result.setValue(key, byteArrayToString(currentValue));
 		}
 	}
 
@@ -92,15 +93,17 @@ ByteArray DIGESTMD5Properties::serialize() const {
 	ByteArray result;
 	for(DIGESTMD5PropertiesMap::const_iterator i = properties.begin(); i != properties.end(); ++i) {
 		if (i != properties.begin()) {
-			result += ',';
+			result.push_back(',');
 		}
-		result += i->first;
-		result += '=';
+		append(result, createByteArray(i->first));
+		result.push_back('=');
 		if (isQuoted(i->first)) {
-			result += "\"" + i->second + "\"";
+			append(result, createByteArray("\""));
+			append(result, i->second);
+			append(result, createByteArray("\""));
 		}
 		else {
-			result += i->second;
+			append(result, i->second);
 		}
 	}
 	return result;
@@ -109,7 +112,7 @@ ByteArray DIGESTMD5Properties::serialize() const {
 boost::optional<std::string> DIGESTMD5Properties::getValue(const std::string& key) const {
 	DIGESTMD5PropertiesMap::const_iterator i = properties.find(key);
 	if (i != properties.end()) {
-		return i->second.toString();
+		return byteArrayToString(i->second);
 	}
 	else {
 		return boost::optional<std::string>();
@@ -117,7 +120,7 @@ boost::optional<std::string> DIGESTMD5Properties::getValue(const std::string& ke
 }
 
 void DIGESTMD5Properties::setValue(const std::string& key, const std::string& value) {
-	properties.insert(DIGESTMD5PropertiesMap::value_type(key, ByteArray(value)));
+	properties.insert(DIGESTMD5PropertiesMap::value_type(key, createByteArray(value)));
 }
 
 bool DIGESTMD5Properties::isQuoted(const std::string& p) {
diff --git a/Swiften/SASL/PLAINClientAuthenticator.cpp b/Swiften/SASL/PLAINClientAuthenticator.cpp
index 1714182..675542f 100644
--- a/Swiften/SASL/PLAINClientAuthenticator.cpp
+++ b/Swiften/SASL/PLAINClientAuthenticator.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <Swiften/SASL/PLAINClientAuthenticator.h>
+#include <Swiften/Base/Concat.h>
 
 namespace Swift {
 
@@ -12,7 +13,7 @@ PLAINClientAuthenticator::PLAINClientAuthenticator() : ClientAuthenticator("PLAI
 }
 
 boost::optional<ByteArray> PLAINClientAuthenticator::getResponse() const {
-	return ByteArray(getAuthorizationID()) + '\0' + ByteArray(getAuthenticationID()) + '\0' + ByteArray(getPassword());
+	return concat(createByteArray(getAuthorizationID()), createByteArray('\0'), createByteArray(getAuthenticationID()), createByteArray('\0'), createByteArray(getPassword()));
 }
 
 bool PLAINClientAuthenticator::setChallenge(const boost::optional<ByteArray>&) {
diff --git a/Swiften/SASL/PLAINClientAuthenticator.h b/Swiften/SASL/PLAINClientAuthenticator.h
index 6a89df1..4e8f8be 100644
--- a/Swiften/SASL/PLAINClientAuthenticator.h
+++ b/Swiften/SASL/PLAINClientAuthenticator.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include <Swiften/SASL/ClientAuthenticator.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class PLAINClientAuthenticator : public ClientAuthenticator {
diff --git a/Swiften/SASL/PLAINMessage.cpp b/Swiften/SASL/PLAINMessage.cpp
index 26261d0..036887c 100644
--- a/Swiften/SASL/PLAINMessage.cpp
+++ b/Swiften/SASL/PLAINMessage.cpp
@@ -13,24 +13,24 @@ PLAINMessage::PLAINMessage(const std::string& authcid, const std::string& passwo
 
 PLAINMessage::PLAINMessage(const ByteArray& value) {
 	size_t i = 0;
-	while (i < value.getSize() && value[i] != '\0') {
+	while (i < value.size() && value[i] != '\0') {
 		authzid += value[i];
 		++i;
 	}
-	if (i == value.getSize()) {
+	if (i == value.size()) {
 		return;
 	}
 	++i;
-	while (i < value.getSize() && value[i] != '\0') {
+	while (i < value.size() && value[i] != '\0') {
 		authcid += value[i];
 		++i;
 	}
-	if (i == value.getSize()) {
+	if (i == value.size()) {
 		authcid = "";
 		return;
 	}
 	++i;
-	while (i < value.getSize()) {
+	while (i < value.size()) {
 		password += value[i];
 		++i;
 	}
@@ -38,7 +38,7 @@ PLAINMessage::PLAINMessage(const ByteArray& value) {
 
 ByteArray PLAINMessage::getValue() const {
 	std::string s = authzid + '\0' + authcid + '\0' + password;
-	return ByteArray(s.c_str(), s.size());
+	return createByteArray(s);
 }
 
 }
diff --git a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
index 7f36e48..bda35b9 100644
--- a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
+++ b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
@@ -15,6 +15,7 @@
 #include <Swiften/StringCodecs/HMACSHA1.h>
 #include <Swiften/StringCodecs/PBKDF2.h>
 #include <Swiften/IDN/StringPrep.h>
+#include <Swiften/Base/Concat.h>
 
 namespace Swift {
 
@@ -40,17 +41,17 @@ SCRAMSHA1ClientAuthenticator::SCRAMSHA1ClientAuthenticator(const std::string& no
 
 boost::optional<ByteArray> SCRAMSHA1ClientAuthenticator::getResponse() const {
 	if (step == Initial) {
-		return getGS2Header() + getInitialBareClientMessage();
+		return concat(getGS2Header(), getInitialBareClientMessage());
 	}
 	else if (step == Proof) {
-		ByteArray clientKey = HMACSHA1::getResult(saltedPassword, "Client Key");
+		ByteArray clientKey = HMACSHA1::getResult(saltedPassword, createByteArray("Client Key"));
 		ByteArray storedKey = SHA1::getHash(clientKey);
 		ByteArray clientSignature = HMACSHA1::getResult(storedKey, authMessage);
 		ByteArray clientProof = clientKey;
-		for (unsigned int i = 0; i < clientProof.getSize(); ++i) {
+		for (unsigned int i = 0; i < clientProof.size(); ++i) {
 			clientProof[i] ^= clientSignature[i];
 		}
-		ByteArray result = getFinalMessageWithoutProof() + ",p=" + Base64::encode(clientProof);
+		ByteArray result = concat(getFinalMessageWithoutProof(), createByteArray(",p="), createByteArray(Base64::encode(clientProof)));
 		return result;
 	}
 	else {
@@ -65,7 +66,7 @@ bool SCRAMSHA1ClientAuthenticator::setChallenge(const boost::optional<ByteArray>
 		}
 		initialServerMessage = *challenge;
 
-		std::map<char, std::string> keys = parseMap(initialServerMessage.toString());
+		std::map<char, std::string> keys = parseMap(byteArrayToString(initialServerMessage));
 
 		// Extract the salt
 		ByteArray salt = Base64::decode(keys['s']);
@@ -79,7 +80,7 @@ bool SCRAMSHA1ClientAuthenticator::setChallenge(const boost::optional<ByteArray>
 		if (receivedClientNonce != clientnonce) {
 			return false;
 		}
-		serverNonce = clientServerNonce.substr(clientnonce.size(), clientServerNonce.npos);
+		serverNonce = createByteArray(clientServerNonce.substr(clientnonce.size(), clientServerNonce.npos));
 
 		// Extract the number of iterations
 		int iterations = 0;
@@ -99,16 +100,16 @@ bool SCRAMSHA1ClientAuthenticator::setChallenge(const boost::optional<ByteArray>
 		}
 
 		// Compute all the values needed for the server signature
-		saltedPassword = PBKDF2::encode(StringPrep::getPrepared(getPassword(), StringPrep::SASLPrep), salt, iterations);
-		authMessage = getInitialBareClientMessage() + "," + initialServerMessage + "," + getFinalMessageWithoutProof();
-		ByteArray serverKey = HMACSHA1::getResult(saltedPassword, "Server Key");
+		saltedPassword = PBKDF2::encode(createByteArray(StringPrep::getPrepared(getPassword(), StringPrep::SASLPrep)), salt, iterations);
+		authMessage = concat(getInitialBareClientMessage(), createByteArray(","), initialServerMessage, createByteArray(","), getFinalMessageWithoutProof());
+		ByteArray serverKey = HMACSHA1::getResult(saltedPassword, createByteArray("Server Key"));
 		serverSignature = HMACSHA1::getResult(serverKey, authMessage);
 
 		step = Proof;
 		return true;
 	}
 	else if (step == Proof) {
-		ByteArray result = ByteArray("v=") + ByteArray(Base64::encode(serverSignature));
+		ByteArray result = concat(createByteArray("v="), createByteArray(Base64::encode(serverSignature)));
 		step = Final;
 		return challenge && challenge == result;
 	}
@@ -147,20 +148,20 @@ std::map<char, std::string> SCRAMSHA1ClientAuthenticator::parseMap(const std::st
 
 ByteArray SCRAMSHA1ClientAuthenticator::getInitialBareClientMessage() const {
 	std::string authenticationID = StringPrep::getPrepared(getAuthenticationID(), StringPrep::SASLPrep);
-	return ByteArray(std::string("n=" + escape(authenticationID) + ",r=" + clientnonce));
+	return createByteArray(std::string("n=" + escape(authenticationID) + ",r=" + clientnonce));
 }
 
 ByteArray SCRAMSHA1ClientAuthenticator::getGS2Header() const {
-	ByteArray channelBindingHeader("n");
+	ByteArray channelBindingHeader(createByteArray("n"));
 	if (tlsChannelBindingData) {
 		if (useChannelBinding) {
-			channelBindingHeader = ByteArray("p=tls-unique");
+			channelBindingHeader = createByteArray("p=tls-unique");
 		}
 		else {
-			channelBindingHeader = ByteArray("y");
+			channelBindingHeader = createByteArray("y");
 		}
 	}
-	return channelBindingHeader + ByteArray(",") + (getAuthorizationID().empty() ? "" : "a=" + escape(getAuthorizationID())) + ",";
+	return concat(channelBindingHeader, createByteArray(","), (getAuthorizationID().empty() ? ByteArray() : createByteArray("a=" + escape(getAuthorizationID()))), createByteArray(","));
 }
 
 void SCRAMSHA1ClientAuthenticator::setTLSChannelBindingData(const ByteArray& channelBindingData) {
@@ -172,7 +173,7 @@ ByteArray SCRAMSHA1ClientAuthenticator::getFinalMessageWithoutProof() const {
 	if (useChannelBinding && tlsChannelBindingData) {
 		channelBindData = *tlsChannelBindingData;
 	}
-	return ByteArray("c=") + Base64::encode(getGS2Header() + channelBindData) + ",r=" + clientnonce + serverNonce;
+	return concat(createByteArray("c=" + Base64::encode(concat(getGS2Header(), channelBindData)) + ",r=" + clientnonce), serverNonce);
 }
 
 
diff --git a/Swiften/SASL/UnitTest/DIGESTMD5ClientAuthenticatorTest.cpp b/Swiften/SASL/UnitTest/DIGESTMD5ClientAuthenticatorTest.cpp
index 84f4620..a16ffac 100644
--- a/Swiften/SASL/UnitTest/DIGESTMD5ClientAuthenticatorTest.cpp
+++ b/Swiften/SASL/UnitTest/DIGESTMD5ClientAuthenticatorTest.cpp
@@ -31,28 +31,28 @@ class DIGESTMD5ClientAuthenticatorTest : public CppUnit::TestFixture {
 			DIGESTMD5ClientAuthenticator testling("xmpp.example.com", "abcdefgh");
 
 			testling.setCredentials("user", "pass", "");
-			testling.setChallenge(ByteArray(
+			testling.setChallenge(createByteArray(
 				"realm=\"example.com\","
 				"nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\","
 				"qop=auth,charset=utf-8,algorithm=md5-sess"));
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=088891c800ecff1b842159ad6459104a,username=\"user\""), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=088891c800ecff1b842159ad6459104a,username=\"user\""), byteArrayToString(response));
 		}
 
 		void testGetResponse_WithAuthorizationID() {
 			DIGESTMD5ClientAuthenticator testling("xmpp.example.com", "abcdefgh");
 
 			testling.setCredentials("user", "pass", "myauthzid");
-			testling.setChallenge(ByteArray(
+			testling.setChallenge(createByteArray(
 				"realm=\"example.com\","
 				"nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\","
 				"qop=auth,charset=utf-8,algorithm=md5-sess"));
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("authzid=\"myauthzid\",charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=4293834432b6e7889a2dee7e8fe7dd06,username=\"user\""), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("authzid=\"myauthzid\",charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=4293834432b6e7889a2dee7e8fe7dd06,username=\"user\""), byteArrayToString(response));
 		}
 };
 
diff --git a/Swiften/SASL/UnitTest/DIGESTMD5PropertiesTest.cpp b/Swiften/SASL/UnitTest/DIGESTMD5PropertiesTest.cpp
index ab04d9b..d664f14 100644
--- a/Swiften/SASL/UnitTest/DIGESTMD5PropertiesTest.cpp
+++ b/Swiften/SASL/UnitTest/DIGESTMD5PropertiesTest.cpp
@@ -19,7 +19,7 @@ class DIGESTMD5PropertiesTest : public CppUnit::TestFixture {
 
 	public:
 		void testParse() {
-			DIGESTMD5Properties properties = DIGESTMD5Properties::parse(ByteArray(
+			DIGESTMD5Properties properties = DIGESTMD5Properties::parse(createByteArray(
 					"realm=\"myrealm1\",realm=\"myrealm2\",nonce=\"mynonce\","
 					"algorithm=md5-sess,charset=utf-8"));
 
@@ -47,8 +47,8 @@ class DIGESTMD5PropertiesTest : public CppUnit::TestFixture {
 			properties.setValue("username", "myuser");
 
 			ByteArray result = properties.serialize();
-			ByteArray expected("authzid=\"myauthzid\",charset=utf-8,cnonce=\"mycnonce\",digest-uri=\"mydigesturi\",nc=1,nonce=\"mynonce\",qop=auth,realm=\"myrealm\",response=myresponse,username=\"myuser\"");
-			CPPUNIT_ASSERT_EQUAL(expected.toString(), result.toString());
+			ByteArray expected(createByteArray("authzid=\"myauthzid\",charset=utf-8,cnonce=\"mycnonce\",digest-uri=\"mydigesturi\",nc=1,nonce=\"mynonce\",qop=auth,realm=\"myrealm\",response=myresponse,username=\"myuser\""));
+			CPPUNIT_ASSERT_EQUAL(byteArrayToString(expected), byteArrayToString(result));
 		}
 };
 
diff --git a/Swiften/SASL/UnitTest/PLAINClientAuthenticatorTest.cpp b/Swiften/SASL/UnitTest/PLAINClientAuthenticatorTest.cpp
index f29d52b..5c35e79 100644
--- a/Swiften/SASL/UnitTest/PLAINClientAuthenticatorTest.cpp
+++ b/Swiften/SASL/UnitTest/PLAINClientAuthenticatorTest.cpp
@@ -6,6 +6,7 @@
 
 #include <Swiften/SASL/PLAINClientAuthenticator.h>
 
+#include <QA/Checker/IO.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
@@ -23,7 +24,7 @@ class PLAINClientAuthenticatorTest : public CppUnit::TestFixture {
 
 			testling.setCredentials("user", "pass");
 
-			CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), ByteArray("\0user\0pass", 10));
+			CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), createByteArray("\0user\0pass", 10));
 		}
 
 		void testGetResponse_WithAuthzID() {
@@ -31,7 +32,7 @@ class PLAINClientAuthenticatorTest : public CppUnit::TestFixture {
 
 			testling.setCredentials("user", "pass", "authz");
 
-			CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), ByteArray("authz\0user\0pass", 15));
+			CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), createByteArray("authz\0user\0pass", 15));
 		}
 };
 
diff --git a/Swiften/SASL/UnitTest/PLAINMessageTest.cpp b/Swiften/SASL/UnitTest/PLAINMessageTest.cpp
index cebfbb2..dc3f82f 100644
--- a/Swiften/SASL/UnitTest/PLAINMessageTest.cpp
+++ b/Swiften/SASL/UnitTest/PLAINMessageTest.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/SASL/PLAINMessage.h>
 
 using namespace Swift;
@@ -29,16 +30,16 @@ class PLAINMessageTest : public CppUnit::TestFixture
 
 		void testGetValue_WithoutAuthzID() {
 			PLAINMessage message("user", "pass");
-			CPPUNIT_ASSERT_EQUAL(message.getValue(), ByteArray("\0user\0pass", 10));
+			CPPUNIT_ASSERT_EQUAL(message.getValue(), createByteArray("\0user\0pass", 10));
 		}
 
 		void testGetValue_WithAuthzID() {
 			PLAINMessage message("user", "pass", "authz");
-			CPPUNIT_ASSERT_EQUAL(message.getValue(), ByteArray("authz\0user\0pass", 15));
+			CPPUNIT_ASSERT_EQUAL(message.getValue(), createByteArray("authz\0user\0pass", 15));
 		}
 
 		void testConstructor_WithoutAuthzID() {
-			PLAINMessage message(ByteArray("\0user\0pass", 10));
+			PLAINMessage message(createByteArray("\0user\0pass", 10));
 
 			CPPUNIT_ASSERT_EQUAL(std::string(""), message.getAuthorizationID());
 			CPPUNIT_ASSERT_EQUAL(std::string("user"), message.getAuthenticationID());
@@ -46,7 +47,7 @@ class PLAINMessageTest : public CppUnit::TestFixture
 		}
 
 		void testConstructor_WithAuthzID() {
-			PLAINMessage message(ByteArray("authz\0user\0pass", 15));
+			PLAINMessage message(createByteArray("authz\0user\0pass", 15));
 
 			CPPUNIT_ASSERT_EQUAL(std::string("authz"), message.getAuthorizationID());
 			CPPUNIT_ASSERT_EQUAL(std::string("user"), message.getAuthenticationID());
@@ -54,13 +55,13 @@ class PLAINMessageTest : public CppUnit::TestFixture
 		}
 
 		void testConstructor_NoAuthcid() {
-			PLAINMessage message(ByteArray("authzid", 7));
+			PLAINMessage message(createByteArray("authzid", 7));
 
 			CPPUNIT_ASSERT_EQUAL(std::string(""), message.getAuthenticationID());
 		}
 
 		void testConstructor_NoPassword() {
-			PLAINMessage message(ByteArray("authzid\0authcid", 15));
+			PLAINMessage message(createByteArray("authzid\0authcid", 15));
 
 			CPPUNIT_ASSERT_EQUAL(std::string(""), message.getAuthenticationID());
 		}
diff --git a/Swiften/SASL/UnitTest/SCRAMSHA1ClientAuthenticatorTest.cpp b/Swiften/SASL/UnitTest/SCRAMSHA1ClientAuthenticatorTest.cpp
index db0d1d3..78afaf7 100644
--- a/Swiften/SASL/UnitTest/SCRAMSHA1ClientAuthenticatorTest.cpp
+++ b/Swiften/SASL/UnitTest/SCRAMSHA1ClientAuthenticatorTest.cpp
@@ -45,7 +45,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("n,,n=user,r=abcdefghABCDEFGH"), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("n,,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));
 		}
 
 		void testGetInitialResponse_UsernameHasSpecialChars() {
@@ -54,7 +54,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("n,,n==2Cus=3D=2Cer=3D,r=abcdefghABCDEFGH"), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("n,,n==2Cus=3D=2Cer=3D,r=abcdefghABCDEFGH"), byteArrayToString(response));
 		}
 
 		void testGetInitialResponse_WithAuthorizationID() {
@@ -63,7 +63,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("n,a=auth,n=user,r=abcdefghABCDEFGH"), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("n,a=auth,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));
 		}
 
 		void testGetInitialResponse_WithAuthorizationIDWithSpecialChars() {
@@ -72,67 +72,67 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("n,a=a=3Du=2Cth,n=user,r=abcdefghABCDEFGH"), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("n,a=a=3Du=2Cth,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));
 		}
 
 		void testGetInitialResponse_WithoutChannelBindingWithTLSChannelBindingData() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", false);
-			testling.setTLSChannelBindingData("xyza");
+			testling.setTLSChannelBindingData(createByteArray("xyza"));
 			testling.setCredentials("user", "pass", "");
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("y,,n=user,r=abcdefghABCDEFGH"), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("y,,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));
 		}
 
 		void testGetInitialResponse_WithChannelBindingWithTLSChannelBindingData() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", true);
-			testling.setTLSChannelBindingData("xyza");
+			testling.setTLSChannelBindingData(createByteArray("xyza"));
 			testling.setCredentials("user", "pass", "");
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("p=tls-unique,,n=user,r=abcdefghABCDEFGH"), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("p=tls-unique,,n=user,r=abcdefghABCDEFGH"), byteArrayToString(response));
 		}
 
 		void testGetFinalResponse() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
-			testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("c=biws,r=abcdefghABCDEFGH,p=CZbjGDpIteIJwQNBgO0P8pKkMGY="), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("c=biws,r=abcdefghABCDEFGH,p=CZbjGDpIteIJwQNBgO0P8pKkMGY="), byteArrayToString(response));
 		}
 
 		void testGetFinalResponse_WithoutChannelBindingWithTLSChannelBindingData() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh", false);
 			testling.setCredentials("user", "pass", "");
-			testling.setTLSChannelBindingData("xyza");
-			testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			testling.setTLSChannelBindingData(createByteArray("xyza"));
+			testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("c=eSws,r=abcdefghABCDEFGH,p=JNpsiFEcxZvNZ1+FFBBqrYvYxMk="), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("c=eSws,r=abcdefghABCDEFGH,p=JNpsiFEcxZvNZ1+FFBBqrYvYxMk="), byteArrayToString(response));
 		}
 
 		void testGetFinalResponse_WithChannelBindingWithTLSChannelBindingData() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh", true);
 			testling.setCredentials("user", "pass", "");
-			testling.setTLSChannelBindingData("xyza");
-			testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			testling.setTLSChannelBindingData(createByteArray("xyza"));
+			testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
 
 			ByteArray response = *testling.getResponse();
 
-			CPPUNIT_ASSERT_EQUAL(std::string("c=cD10bHMtdW5pcXVlLCx4eXph,r=abcdefghABCDEFGH,p=i6Rghite81P1ype8XxaVAa5l7v0="), response.toString());
+			CPPUNIT_ASSERT_EQUAL(std::string("c=cD10bHMtdW5pcXVlLCx4eXph,r=abcdefghABCDEFGH,p=i6Rghite81P1ype8XxaVAa5l7v0="), byteArrayToString(response));
 		}
 
 		void testSetFinalChallenge() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
-			testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
 
-			bool result = testling.setChallenge(ByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));
+			bool result = testling.setChallenge(createByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));
 
 			CPPUNIT_ASSERT(result);
 		}
@@ -141,7 +141,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
 
-			bool result = testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
 
 			CPPUNIT_ASSERT(result);
 		}
@@ -150,7 +150,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
 
-			bool result = testling.setChallenge(ByteArray("r=abcdefgiABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			bool result = testling.setChallenge(createByteArray("r=abcdefgiABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
 
 			CPPUNIT_ASSERT(!result);
 		}
@@ -159,7 +159,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
 
-			bool result = testling.setChallenge(ByteArray("r=abcdefgh,s=MTIzNDU2NzgK,i=4096"));
+			bool result = testling.setChallenge(createByteArray("r=abcdefgh,s=MTIzNDU2NzgK,i=4096"));
 
 			CPPUNIT_ASSERT(!result);
 		}
@@ -168,7 +168,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
 
-			bool result = testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=bla"));
+			bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=bla"));
 
 			CPPUNIT_ASSERT(!result);
 		}
@@ -177,7 +177,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
 
-			bool result = testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK"));
+			bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK"));
 
 			CPPUNIT_ASSERT(!result);
 		}
@@ -186,7 +186,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
 
-			bool result = testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=0"));
+			bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=0"));
 
 			CPPUNIT_ASSERT(!result);
 		}
@@ -195,7 +195,7 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
 
-			bool result = testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=-1"));
+			bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=-1"));
 
 			CPPUNIT_ASSERT(!result);
 		}
@@ -203,8 +203,8 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 		void testSetFinalChallenge_InvalidChallenge() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
-			testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
-			bool result = testling.setChallenge(ByteArray("v=e26kI69ICb6zosapLLxrER/631A="));
+			testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			bool result = testling.setChallenge(createByteArray("v=e26kI69ICb6zosapLLxrER/631A="));
 
 			CPPUNIT_ASSERT(!result);
 		}
@@ -212,8 +212,8 @@ class SCRAMSHA1ClientAuthenticatorTest : public CppUnit::TestFixture {
 		void testGetResponseAfterFinalChallenge() {
 			SCRAMSHA1ClientAuthenticator testling("abcdefgh");
 			testling.setCredentials("user", "pass", "");
-			testling.setChallenge(ByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
-			testling.setChallenge(ByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));
+			testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));
+			testling.setChallenge(createByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));
 
 			CPPUNIT_ASSERT(!testling.getResponse());
 		}
diff --git a/Swiften/Serializer/AuthChallengeSerializer.cpp b/Swiften/Serializer/AuthChallengeSerializer.cpp
index 18d190d..6848ad1 100644
--- a/Swiften/Serializer/AuthChallengeSerializer.cpp
+++ b/Swiften/Serializer/AuthChallengeSerializer.cpp
@@ -8,6 +8,7 @@
 
 #include <Swiften/Elements/AuthChallenge.h>
 #include <Swiften/StringCodecs/Base64.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 
@@ -17,13 +18,13 @@ AuthChallengeSerializer::AuthChallengeSerializer() {
 std::string AuthChallengeSerializer::serialize(boost::shared_ptr<Element> element)  const {
 	boost::shared_ptr<AuthChallenge> authChallenge(boost::dynamic_pointer_cast<AuthChallenge>(element));
 	std::string value;
-	boost::optional<ByteArray> message = authChallenge->getValue();
+	boost::optional<std::vector<unsigned char> > message = authChallenge->getValue();
 	if (message) {
-		if ((*message).isEmpty()) {
+		if ((*message).empty()) {
 			value = "=";
 		}
 		else {
-			value = Base64::encode(*message);
+			value = Base64::encode(ByteArray(*message));
 		}
 	}
 	return "<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</challenge>";
diff --git a/Swiften/Serializer/AuthRequestSerializer.cpp b/Swiften/Serializer/AuthRequestSerializer.cpp
index 4ba3e47..415a0ff 100644
--- a/Swiften/Serializer/AuthRequestSerializer.cpp
+++ b/Swiften/Serializer/AuthRequestSerializer.cpp
@@ -8,6 +8,7 @@
 
 #include <Swiften/Elements/AuthRequest.h>
 #include <Swiften/StringCodecs/Base64.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 
@@ -17,13 +18,13 @@ AuthRequestSerializer::AuthRequestSerializer() {
 std::string AuthRequestSerializer::serialize(boost::shared_ptr<Element> element)  const {
 	boost::shared_ptr<AuthRequest> authRequest(boost::dynamic_pointer_cast<AuthRequest>(element));
 	std::string value;
-	boost::optional<ByteArray> message = authRequest->getMessage();
+	boost::optional<std::vector<unsigned char> > message = authRequest->getMessage();
 	if (message) {
-		if ((*message).isEmpty()) {
+		if ((*message).empty()) {
 			value = "=";
 		}
 		else {
-			value = Base64::encode(*message);
+			value = Base64::encode(ByteArray(*message));
 		}
 	}
 	return "<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"" + authRequest->getMechanism() + "\">" + value + "</auth>";
diff --git a/Swiften/Serializer/AuthResponseSerializer.cpp b/Swiften/Serializer/AuthResponseSerializer.cpp
index 9bd1cc1..0d1872b 100644
--- a/Swiften/Serializer/AuthResponseSerializer.cpp
+++ b/Swiften/Serializer/AuthResponseSerializer.cpp
@@ -8,6 +8,7 @@
 
 #include <Swiften/Elements/AuthResponse.h>
 #include <Swiften/StringCodecs/Base64.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 
@@ -17,13 +18,13 @@ AuthResponseSerializer::AuthResponseSerializer() {
 std::string AuthResponseSerializer::serialize(boost::shared_ptr<Element> element)	const {
 	boost::shared_ptr<AuthResponse> authResponse(boost::dynamic_pointer_cast<AuthResponse>(element));
 	std::string value;
-	boost::optional<ByteArray> message = authResponse->getValue();
+	boost::optional<std::vector<unsigned char> > message = authResponse->getValue();
 	if (message) {
-		if ((*message).isEmpty()) {
+		if ((*message).empty()) {
 			value = "=";
 		}
 		else {
-			value = Base64::encode(*message);
+			value = Base64::encode(ByteArray(*message));
 		}
 	}
 	return "<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</response>";
diff --git a/Swiften/Serializer/AuthSuccessSerializer.cpp b/Swiften/Serializer/AuthSuccessSerializer.cpp
index 518c970..12aab8f 100644
--- a/Swiften/Serializer/AuthSuccessSerializer.cpp
+++ b/Swiften/Serializer/AuthSuccessSerializer.cpp
@@ -8,6 +8,7 @@
 
 #include <Swiften/Elements/AuthSuccess.h>
 #include <Swiften/StringCodecs/Base64.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 
@@ -17,13 +18,13 @@ AuthSuccessSerializer::AuthSuccessSerializer() {
 std::string AuthSuccessSerializer::serialize(boost::shared_ptr<Element> element)  const {
 	boost::shared_ptr<AuthSuccess> authSuccess(boost::dynamic_pointer_cast<AuthSuccess>(element));
 	std::string value;
-	boost::optional<ByteArray> message = authSuccess->getValue();
+	boost::optional<std::vector<unsigned char> > message = authSuccess->getValue();
 	if (message) {
-		if ((*message).isEmpty()) {
+		if ((*message).empty()) {
 			value = "=";
 		}
 		else {
-			value = Base64::encode(*message);
+			value = Base64::encode(ByteArray(*message));
 		}
 	}
 	return "<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">" + value + "</success>";
diff --git a/Swiften/Serializer/PayloadSerializers/UnitTest/VCardSerializerTest.cpp b/Swiften/Serializer/PayloadSerializers/UnitTest/VCardSerializerTest.cpp
index 5122d22..3ac1d77 100644
--- a/Swiften/Serializer/PayloadSerializers/UnitTest/VCardSerializerTest.cpp
+++ b/Swiften/Serializer/PayloadSerializers/UnitTest/VCardSerializerTest.cpp
@@ -29,7 +29,7 @@ class VCardSerializerTest : public CppUnit::TestFixture
 			vcard->setFamilyName("Wonderland");
 			vcard->setSuffix("PhD");
 			vcard->setNickname("DreamGirl");
-			vcard->setPhoto("abcdef");
+			vcard->setPhoto(createByteArray("abcdef"));
 			vcard->setPhotoType("image/png");
 			vcard->addUnknownContent("<BDAY>1234</BDAY><MAILER>mutt</MAILER>");
 
diff --git a/Swiften/Serializer/PayloadSerializers/VCardSerializer.cpp b/Swiften/Serializer/PayloadSerializers/VCardSerializer.cpp
index ab6aa1e..17a6b49 100644
--- a/Swiften/Serializer/PayloadSerializers/VCardSerializer.cpp
+++ b/Swiften/Serializer/PayloadSerializers/VCardSerializer.cpp
@@ -87,14 +87,14 @@ std::string VCardSerializer::serializePayload(boost::shared_ptr<VCard> vcard)  c
 		nickElement->addNode(boost::shared_ptr<XMLTextNode>(new XMLTextNode(vcard->getNickname())));
 		queryElement.addNode(nickElement);
 	}
-	if (!vcard->getPhoto().isEmpty() || !vcard->getPhotoType().empty()) {
+	if (!vcard->getPhoto().empty() || !vcard->getPhotoType().empty()) {
 		XMLElement::ref photoElement(new XMLElement("PHOTO"));
 		if (!vcard->getPhotoType().empty()) {
 			XMLElement::ref typeElement(new XMLElement("TYPE"));
 			typeElement->addNode(XMLTextNode::ref(new XMLTextNode(vcard->getPhotoType())));
 			photoElement->addNode(typeElement);
 		}
-		if (!vcard->getPhoto().isEmpty()) {
+		if (!vcard->getPhoto().empty()) {
 			XMLElement::ref binvalElement(new XMLElement("BINVAL"));
 			binvalElement->addNode(XMLTextNode::ref(new XMLTextNode(Base64::encode(vcard->getPhoto()))));
 			photoElement->addNode(binvalElement);
diff --git a/Swiften/Serializer/UnitTest/AuthChallengeSerializerTest.cpp b/Swiften/Serializer/UnitTest/AuthChallengeSerializerTest.cpp
index f044607..a81620d 100644
--- a/Swiften/Serializer/UnitTest/AuthChallengeSerializerTest.cpp
+++ b/Swiften/Serializer/UnitTest/AuthChallengeSerializerTest.cpp
@@ -9,6 +9,7 @@
 
 #include <Swiften/Serializer/AuthChallengeSerializer.h>
 #include <Swiften/Elements/AuthChallenge.h>
+#include <Swiften/Base/ByteArray.h>
 
 using namespace Swift;
 
@@ -23,7 +24,7 @@ class AuthChallengeSerializerTest : public CppUnit::TestFixture {
 		void testSerialize() {
 			AuthChallengeSerializer testling;
 			boost::shared_ptr<AuthChallenge> authChallenge(new AuthChallenge());
-			authChallenge->setValue("foo");
+			authChallenge->setValue(createByteArray("foo"));
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"
@@ -43,7 +44,7 @@ class AuthChallengeSerializerTest : public CppUnit::TestFixture {
 		void testSerialize_EmptyMessage() {
 			AuthChallengeSerializer testling;
 			boost::shared_ptr<AuthChallenge> authChallenge(new AuthChallenge());
-			authChallenge->setValue(ByteArray());
+			authChallenge->setValue(std::vector<unsigned char>());
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"
diff --git a/Swiften/Serializer/UnitTest/AuthRequestSerializerTest.cpp b/Swiften/Serializer/UnitTest/AuthRequestSerializerTest.cpp
index eff2c8e..8270139 100644
--- a/Swiften/Serializer/UnitTest/AuthRequestSerializerTest.cpp
+++ b/Swiften/Serializer/UnitTest/AuthRequestSerializerTest.cpp
@@ -9,6 +9,7 @@
 
 #include <Swiften/Serializer/AuthRequestSerializer.h>
 #include <Swiften/Elements/AuthRequest.h>
+#include <Swiften/Base/ByteArray.h>
 
 using namespace Swift;
 
@@ -23,7 +24,7 @@ class AuthRequestSerializerTest : public CppUnit::TestFixture {
 		void testSerialize() {
 			AuthRequestSerializer testling;
 			boost::shared_ptr<AuthRequest> authRequest(new AuthRequest("PLAIN"));
-			authRequest->setMessage("foo");
+			authRequest->setMessage(createByteArray("foo"));
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"PLAIN\">"
@@ -43,7 +44,7 @@ class AuthRequestSerializerTest : public CppUnit::TestFixture {
 		void testSerialize_EmptyMessage() {
 			AuthRequestSerializer testling;
 			boost::shared_ptr<AuthRequest> authRequest(new AuthRequest("PLAIN"));
-			authRequest->setMessage(ByteArray());
+			authRequest->setMessage(std::vector<unsigned char>());
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<auth xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\" mechanism=\"PLAIN\">"
diff --git a/Swiften/Serializer/UnitTest/AuthResponseSerializerTest.cpp b/Swiften/Serializer/UnitTest/AuthResponseSerializerTest.cpp
index f14d184..e790cc3 100644
--- a/Swiften/Serializer/UnitTest/AuthResponseSerializerTest.cpp
+++ b/Swiften/Serializer/UnitTest/AuthResponseSerializerTest.cpp
@@ -9,6 +9,7 @@
 
 #include <Swiften/Serializer/AuthResponseSerializer.h>
 #include <Swiften/Elements/AuthResponse.h>
+#include <Swiften/Base/ByteArray.h>
 
 using namespace Swift;
 
@@ -23,7 +24,7 @@ class AuthResponseSerializerTest : public CppUnit::TestFixture {
 		void testSerialize() {
 			AuthResponseSerializer testling;
 			boost::shared_ptr<AuthResponse> authResponse(new AuthResponse());
-			authResponse->setValue("foo");
+			authResponse->setValue(createByteArray("foo"));
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"
@@ -43,7 +44,7 @@ class AuthResponseSerializerTest : public CppUnit::TestFixture {
 		void testSerialize_EmptyMessage() {
 			AuthResponseSerializer testling;
 			boost::shared_ptr<AuthResponse> authResponse(new AuthResponse());
-			authResponse->setValue(ByteArray());
+			authResponse->setValue(std::vector<unsigned char>());
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<response xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"
diff --git a/Swiften/Serializer/UnitTest/AuthSuccessSerializerTest.cpp b/Swiften/Serializer/UnitTest/AuthSuccessSerializerTest.cpp
index 0f6987c..a9f6de2 100644
--- a/Swiften/Serializer/UnitTest/AuthSuccessSerializerTest.cpp
+++ b/Swiften/Serializer/UnitTest/AuthSuccessSerializerTest.cpp
@@ -9,6 +9,7 @@
 
 #include <Swiften/Serializer/AuthSuccessSerializer.h>
 #include <Swiften/Elements/AuthSuccess.h>
+#include <Swiften/Base/ByteArray.h>
 
 using namespace Swift;
 
@@ -23,7 +24,7 @@ class AuthSuccessSerializerTest : public CppUnit::TestFixture {
 		void testSerialize() {
 			AuthSuccessSerializer testling;
 			boost::shared_ptr<AuthSuccess> authSuccess(new AuthSuccess());
-			authSuccess->setValue("foo");
+			authSuccess->setValue(createByteArray("foo"));
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"
@@ -43,7 +44,7 @@ class AuthSuccessSerializerTest : public CppUnit::TestFixture {
 		void testSerialize_EmptyMessage() {
 			AuthSuccessSerializer testling;
 			boost::shared_ptr<AuthSuccess> authSuccess(new AuthSuccess());
-			authSuccess->setValue(ByteArray());
+			authSuccess->setValue(std::vector<unsigned char>());
 
 			CPPUNIT_ASSERT_EQUAL(std::string(
 				"<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">"
diff --git a/Swiften/Server/ServerFromClientSession.cpp b/Swiften/Server/ServerFromClientSession.cpp
index 3c9321b..b047f69 100644
--- a/Swiften/Server/ServerFromClientSession.cpp
+++ b/Swiften/Server/ServerFromClientSession.cpp
@@ -51,7 +51,7 @@ void ServerFromClientSession::handleElement(boost::shared_ptr<Element> element)
 						getXMPPLayer()->resetParser();
 				}
 				else {
-					PLAINMessage plainMessage(authRequest->getMessage() ? *authRequest->getMessage() : "");
+					PLAINMessage plainMessage(authRequest->getMessage() ? *authRequest->getMessage() : createByteArray(""));
 					if (userRegistry_->isValidUserPassword(JID(plainMessage.getAuthenticationID(), getLocalJID().getDomain()), plainMessage.getPassword())) {
 						getXMPPLayer()->writeElement(boost::shared_ptr<AuthSuccess>(new AuthSuccess()));
 						user_ = plainMessage.getAuthenticationID();
diff --git a/Swiften/Server/ServerFromClientSession.h b/Swiften/Server/ServerFromClientSession.h
index b35a3c2..1a0e109 100644
--- a/Swiften/Server/ServerFromClientSession.h
+++ b/Swiften/Server/ServerFromClientSession.h
@@ -14,6 +14,7 @@
 #include <Swiften/Session/Session.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Network/Connection.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class ProtocolHeader;
@@ -26,7 +27,6 @@ namespace Swift {
 	class XMPPLayer;
 	class ConnectionLayer;
 	class Connection;
-	class ByteArray;
 
 	class ServerFromClientSession : public Session {
 		public:
diff --git a/Swiften/Session/BasicSessionStream.cpp b/Swiften/Session/BasicSessionStream.cpp
index 7e5f24b..579631f 100644
--- a/Swiften/Session/BasicSessionStream.cpp
+++ b/Swiften/Session/BasicSessionStream.cpp
@@ -193,11 +193,11 @@ void BasicSessionStream::handleConnectionFinished(const boost::optional<Connecti
 }
 
 void BasicSessionStream::handleDataRead(const ByteArray& data) {
-	onDataRead(data.toString());
+	onDataRead(byteArrayToString(data));
 }
 
 void BasicSessionStream::handleDataWritten(const ByteArray& data) {
-	onDataWritten(data.toString());
+	onDataWritten(byteArrayToString(data));
 }
 
 };
diff --git a/Swiften/Session/Session.h b/Swiften/Session/Session.h
index d399cd1..04ae8d5 100644
--- a/Swiften/Session/Session.h
+++ b/Swiften/Session/Session.h
@@ -15,13 +15,13 @@
 #include <Swiften/Elements/Element.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/StreamStack/ConnectionLayer.h>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class ProtocolHeader;
 	class StreamStack;
 	class JID;
 	class Element;
-	class ByteArray;
 	class PayloadParserFactoryCollection;
 	class PayloadSerializerCollection;
 	class XMPPLayer;
diff --git a/Swiften/Session/SessionTracer.cpp b/Swiften/Session/SessionTracer.cpp
index 6d41e40..060109b 100644
--- a/Swiften/Session/SessionTracer.cpp
+++ b/Swiften/Session/SessionTracer.cpp
@@ -22,7 +22,7 @@ void SessionTracer::printData(char direction, const ByteArray& data) {
 		std::cerr << direction;
 	}
 	std::cerr << " " << session->getRemoteJID()<< " " << direction << direction << std::endl;
-	std::cerr << data.toString() << std::endl;
+	std::cerr << byteArrayToString(data) << std::endl;
 }
 
 }
diff --git a/Swiften/StreamStack/UnitTest/StreamStackTest.cpp b/Swiften/StreamStack/UnitTest/StreamStackTest.cpp
index 97d29c9..19dd37c 100644
--- a/Swiften/StreamStack/UnitTest/StreamStackTest.cpp
+++ b/Swiften/StreamStack/UnitTest/StreamStackTest.cpp
@@ -12,7 +12,9 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Base/ByteArray.h>
+#include <Swiften/Base/Concat.h>
 #include <Swiften/StreamStack/StreamStack.h>
 #include <Swiften/StreamStack/LowLayer.h>
 #include <Swiften/StreamStack/XMPPLayer.h>
@@ -52,7 +54,7 @@ class StreamStackTest : public CppUnit::TestFixture {
 			xmppStream_->writeData("foo");
 
 			CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), physicalStream_->data_.size());
-			CPPUNIT_ASSERT_EQUAL(ByteArray("foo"), physicalStream_->data_[0]);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("foo"), physicalStream_->data_[0]);
 		}
 
 		void testWriteData_OneIntermediateStream() {
@@ -63,7 +65,7 @@ class StreamStackTest : public CppUnit::TestFixture {
 			xmppStream_->writeData("foo");
 
 			CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), physicalStream_->data_.size());
-			CPPUNIT_ASSERT_EQUAL(ByteArray("Xfoo"), physicalStream_->data_[0]);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("Xfoo"), physicalStream_->data_[0]);
 		}
 
 		void testWriteData_TwoIntermediateStreamStack() {
@@ -76,14 +78,14 @@ class StreamStackTest : public CppUnit::TestFixture {
 			xmppStream_->writeData("foo");
 
 			CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(1), physicalStream_->data_.size());
-			CPPUNIT_ASSERT_EQUAL(ByteArray("XYfoo"), physicalStream_->data_[0]);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("XYfoo"), physicalStream_->data_[0]);
 		}
 
 		void testReadData_NoIntermediateStreamStack() {
 			StreamStack testling(xmppStream_, physicalStream_);
 			xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));
 			
-			physicalStream_->onDataRead(ByteArray("<stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
+			physicalStream_->onDataRead(createByteArray("<stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);
 		}
@@ -94,7 +96,7 @@ class StreamStackTest : public CppUnit::TestFixture {
 			boost::shared_ptr<MyStreamLayer> xStream(new MyStreamLayer("<"));
 			testling.addLayer(xStream.get());
 
-			physicalStream_->onDataRead(ByteArray("stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
+			physicalStream_->onDataRead(createByteArray("stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);
 		}
@@ -107,7 +109,7 @@ class StreamStackTest : public CppUnit::TestFixture {
 			testling.addLayer(xStream.get());
 			testling.addLayer(yStream.get());
 
-			physicalStream_->onDataRead(ByteArray("tream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
+			physicalStream_->onDataRead(createByteArray("tream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);
 		}
@@ -138,11 +140,11 @@ class StreamStackTest : public CppUnit::TestFixture {
 				}
 
 				virtual void writeData(const ByteArray& data) {
-					writeDataToChildLayer(ByteArray(prepend_) + data);
+					writeDataToChildLayer(concat(createByteArray(prepend_), data));
 				}
 
 				virtual void handleDataRead(const ByteArray& data) {
-					writeDataToParentLayer(ByteArray(prepend_) + data);
+					writeDataToParentLayer(concat(createByteArray(prepend_), data));
 				}
 
 			private:
diff --git a/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp b/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp
index f6a75c1..602699d 100644
--- a/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp
+++ b/Swiften/StreamStack/UnitTest/XMPPLayerTest.cpp
@@ -46,7 +46,7 @@ class XMPPLayerTest : public CppUnit::TestFixture {
 		void testParseData_Error() {
 			testling_->onError.connect(boost::bind(&XMPPLayerTest::handleError, this));
 
-			testling_->handleDataRead("<iq>");
+			testling_->handleDataRead(createByteArray("<iq>"));
 			
 			CPPUNIT_ASSERT_EQUAL(1, errorReceived_);
 		}
@@ -55,10 +55,10 @@ class XMPPLayerTest : public CppUnit::TestFixture {
 			testling_->onElement.connect(boost::bind(&XMPPLayerTest::handleElement, this, _1));
 			testling_->onError.connect(boost::bind(&XMPPLayerTest::handleError, this));
 
-			testling_->handleDataRead("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >");
+			testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >"));
 			testling_->resetParser();
-			testling_->handleDataRead("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >");
-			testling_->handleDataRead("<presence/>");
+			testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" >"));
+			testling_->handleDataRead(createByteArray("<presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(1, elementsReceived_);
 			CPPUNIT_ASSERT_EQUAL(0, errorReceived_);
@@ -66,8 +66,8 @@ class XMPPLayerTest : public CppUnit::TestFixture {
 
 		void testResetParser_FromSlot() {
 			testling_->onElement.connect(boost::bind(&XMPPLayerTest::handleElementAndReset, this, _1));
-			testling_->handleDataRead("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>");
-			testling_->handleDataRead("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>");
+			testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>"));
+			testling_->handleDataRead(createByteArray("<stream:stream to=\"example.com\" xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" ><presence/>"));
 
 			CPPUNIT_ASSERT_EQUAL(2, elementsReceived_);
 			CPPUNIT_ASSERT_EQUAL(0, errorReceived_);
@@ -121,7 +121,7 @@ class XMPPLayerTest : public CppUnit::TestFixture {
 		class DummyLowLayer : public LowLayer {
 			public:
 				virtual void writeData(const ByteArray& data) {
-					writtenData += data.toString();
+					writtenData += byteArrayToString(data);
 				}
 				
 				std::string writtenData;
diff --git a/Swiften/StreamStack/WhitespacePingLayer.cpp b/Swiften/StreamStack/WhitespacePingLayer.cpp
index 9fb4b06..6a95899 100644
--- a/Swiften/StreamStack/WhitespacePingLayer.cpp
+++ b/Swiften/StreamStack/WhitespacePingLayer.cpp
@@ -30,7 +30,7 @@ void WhitespacePingLayer::handleDataRead(const ByteArray& data) {
 
 void WhitespacePingLayer::handleTimerTick() {
 	timer->stop();
-	writeDataToChildLayer(" ");
+	writeDataToChildLayer(createByteArray(" "));
 	timer->start();
 }
 
diff --git a/Swiften/StreamStack/XMPPLayer.cpp b/Swiften/StreamStack/XMPPLayer.cpp
index 3c7dcb4..37cda65 100644
--- a/Swiften/StreamStack/XMPPLayer.cpp
+++ b/Swiften/StreamStack/XMPPLayer.cpp
@@ -29,19 +29,19 @@ XMPPLayer::~XMPPLayer() {
 }
 
 void XMPPLayer::writeHeader(const ProtocolHeader& header) {
-	writeDataInternal(ByteArray(xmppSerializer_->serializeHeader(header)));
+	writeDataInternal(createByteArray(xmppSerializer_->serializeHeader(header)));
 }
 
 void XMPPLayer::writeFooter() {
-	writeDataInternal(ByteArray(xmppSerializer_->serializeFooter()));
+	writeDataInternal(createByteArray(xmppSerializer_->serializeFooter()));
 }
 
 void XMPPLayer::writeElement(boost::shared_ptr<Element> element) {
-	writeDataInternal(ByteArray(xmppSerializer_->serializeElement(element)));
+	writeDataInternal(createByteArray(xmppSerializer_->serializeElement(element)));
 }
 
 void XMPPLayer::writeData(const std::string& data) {
-	writeDataInternal(ByteArray(data));
+	writeDataInternal(createByteArray(data));
 }
 
 void XMPPLayer::writeDataInternal(const ByteArray& data) {
@@ -52,7 +52,7 @@ void XMPPLayer::writeDataInternal(const ByteArray& data) {
 void XMPPLayer::handleDataRead(const ByteArray& data) {
 	onDataRead(data);
 	inParser_ = true;
-	if (!xmppParser_->parse(data.toString())) {
+	if (!xmppParser_->parse(byteArrayToString(data))) {
 		inParser_ = false;
 		onError();
 		return;
diff --git a/Swiften/StringCodecs/Base64.cpp b/Swiften/StringCodecs/Base64.cpp
index a77fc93..4ec2e16 100644
--- a/Swiften/StringCodecs/Base64.cpp
+++ b/Swiften/StringCodecs/Base64.cpp
@@ -17,7 +17,7 @@ namespace Swift {
 
 std::string Base64::encode(const ByteArray &s) {
 	int i;
-	int len = s.getSize();
+	int len = s.size();
 	char tbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 	int a, b, c;
 
diff --git a/Swiften/StringCodecs/HMACSHA1.cpp b/Swiften/StringCodecs/HMACSHA1.cpp
index 6f88d68..e583e3b 100644
--- a/Swiften/StringCodecs/HMACSHA1.cpp
+++ b/Swiften/StringCodecs/HMACSHA1.cpp
@@ -10,13 +10,14 @@
 
 #include <Swiften/StringCodecs/SHA1.h>
 #include <Swiften/Base/ByteArray.h>
+#include <Swiften/Base/Algorithm.h>
 
 namespace Swift {
 
 static const unsigned int B = 64;
 
 ByteArray HMACSHA1::getResult(const ByteArray& key, const ByteArray& data) {
-	assert(key.getSize() <= B);
+	assert(key.size() <= B);
 
 	// Create the padded key
 	ByteArray paddedKey(key);
@@ -24,17 +25,17 @@ ByteArray HMACSHA1::getResult(const ByteArray& key, const ByteArray& data) {
 
 	// Create the first value
 	ByteArray x(paddedKey);
-	for (unsigned int i = 0; i < x.getSize(); ++i) {
+	for (unsigned int i = 0; i < x.size(); ++i) {
 		x[i] ^= 0x36;
 	}
-	x += data;
+	append(x, data);
 
 	// Create the second value
 	ByteArray y(paddedKey);
-	for (unsigned int i = 0; i < y.getSize(); ++i) {
+	for (unsigned int i = 0; i < y.size(); ++i) {
 		y[i] ^= 0x5c;
 	}
-	y += SHA1::getHash(x);
+	append(y, SHA1::getHash(x));
 
 	return SHA1::getHash(y);
 }
@@ -53,19 +54,19 @@ ByteArray HMACSHA1::getResult(const ByteArray& key, const ByteArray& data) {
 
 void HMACSHA1::getResult(const ByteArray& key, const ByteArray& data, ByteArray& result) {
 	// Create first value
-	size_t xSize = B + data.getSize();
+	size_t xSize = B + data.size();
 	unsigned char* x = (unsigned char*) malloc(xSize * sizeof(unsigned char));
 	memset(x, 0, B);
-	memcpy(x, key.getData(), key.getSize());
+	memcpy(x, key.getData(), key.size());
 	for (unsigned int i = 0; i < (B>>32); ++i) {
 		x[i<<32] ^= 0x36363636;
 	}
-	memcpy(x + B, data.getData(), data.getSize());
+	memcpy(x + B, data.getData(), data.size());
 
 	// Create the second value
 	unsigned char y[B + 20];
 	memset(y, 0, B);
-	memcpy(y, key.getData(), key.getSize());
+	memcpy(y, key.getData(), key.size());
 	for (unsigned int i = 0; i < (B>>32); ++i) {
 		y[i<<32] ^= 0x5c5c5c5c;
 	}
diff --git a/Swiften/StringCodecs/HMACSHA1.h b/Swiften/StringCodecs/HMACSHA1.h
index cc6cb04..39c6e4e 100644
--- a/Swiften/StringCodecs/HMACSHA1.h
+++ b/Swiften/StringCodecs/HMACSHA1.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
-namespace Swift {
-	class ByteArray;
+#include <Swiften/Base/ByteArray.h>
 
+namespace Swift {
 	class HMACSHA1 {
 		public:
 			static ByteArray getResult(const ByteArray& key, const ByteArray& data);
diff --git a/Swiften/StringCodecs/Hexify.cpp b/Swiften/StringCodecs/Hexify.cpp
index 05b7d66..367743c 100644
--- a/Swiften/StringCodecs/Hexify.cpp
+++ b/Swiften/StringCodecs/Hexify.cpp
@@ -25,7 +25,7 @@ std::string Hexify::hexify(const ByteArray& data) {
 	std::ostringstream result;
 	result << std::hex;
 
-	for (unsigned int i = 0; i < data.getSize(); ++i) {
+	for (unsigned int i = 0; i < data.size(); ++i) {
 		result << std::setw(2) << std::setfill('0') << boost::numeric_cast<unsigned int>(static_cast<unsigned char>(data[i]));
 	}
 	return std::string(result.str());
diff --git a/Swiften/StringCodecs/Hexify.h b/Swiften/StringCodecs/Hexify.h
index f85db15..9815e21 100644
--- a/Swiften/StringCodecs/Hexify.h
+++ b/Swiften/StringCodecs/Hexify.h
@@ -6,12 +6,9 @@
 
 #pragma once
 
-#include <string>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
-	
-	class ByteArray;
-
 	class Hexify {
 		public:
 			static std::string hexify(unsigned char byte);
diff --git a/Swiften/StringCodecs/MD5.cpp b/Swiften/StringCodecs/MD5.cpp
index 07dcd8b..9e69172 100644
--- a/Swiften/StringCodecs/MD5.cpp
+++ b/Swiften/StringCodecs/MD5.cpp
@@ -36,6 +36,7 @@
 #include <Swiften/StringCodecs/MD5.h>
 
 #include <cassert>
+#include <string.h>
 
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/Base/Platform.h>
@@ -356,8 +357,8 @@ ByteArray MD5::getHash(const ByteArray& data) {
 
 	md5_state_t state;
 	md5_init(&state);
-	md5_append(&state, reinterpret_cast<const md5_byte_t*>(data.getData()), data.getSize());
-	md5_finish(&state, reinterpret_cast<md5_byte_t*>(digest.getData()));
+	md5_append(&state, reinterpret_cast<const md5_byte_t*>(vecptr(data)), data.size());
+	md5_finish(&state, reinterpret_cast<md5_byte_t*>(vecptr(digest)));
 
 	return digest;
 }
diff --git a/Swiften/StringCodecs/MD5.h b/Swiften/StringCodecs/MD5.h
index b896529..93c48e9 100644
--- a/Swiften/StringCodecs/MD5.h
+++ b/Swiften/StringCodecs/MD5.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
-namespace Swift {
-	class ByteArray;
+#include <Swiften/Base/ByteArray.h>
 
+namespace Swift {
 	class MD5 {
 		public:
 			static ByteArray getHash(const ByteArray& data);
diff --git a/Swiften/StringCodecs/PBKDF2.cpp b/Swiften/StringCodecs/PBKDF2.cpp
index f5b6126..c4a5a7f 100644
--- a/Swiften/StringCodecs/PBKDF2.cpp
+++ b/Swiften/StringCodecs/PBKDF2.cpp
@@ -6,16 +6,17 @@
 
 #include <Swiften/StringCodecs/PBKDF2.h>
 #include <Swiften/StringCodecs/HMACSHA1.h>
+#include <Swiften/Base/Concat.h>
 
 namespace Swift {
 
 ByteArray PBKDF2::encode(const ByteArray& password, const ByteArray& salt, int iterations) {
-	ByteArray u = HMACSHA1::getResult(password, salt + ByteArray("\0\0\0\1", 4));
-	ByteArray result = u;
+	ByteArray u = HMACSHA1::getResult(password, concat(salt, createByteArray("\0\0\0\1", 4)));
+	ByteArray result(u);
 	int i = 1;
 	while (i < iterations) {
 		u = HMACSHA1::getResult(password, u);
-		for (unsigned int j = 0; j < u.getSize(); ++j) {
+		for (unsigned int j = 0; j < u.size(); ++j) {
 			result[j] ^= u[j];
 		}
 		++i;
diff --git a/Swiften/StringCodecs/SHA1.cpp b/Swiften/StringCodecs/SHA1.cpp
index eb667a8..5001fb2 100644
--- a/Swiften/StringCodecs/SHA1.cpp
+++ b/Swiften/StringCodecs/SHA1.cpp
@@ -185,7 +185,7 @@ SHA1::SHA1() {
 
 SHA1& SHA1::update(const std::vector<unsigned char>& input) {
 	std::vector<unsigned char> inputCopy(input);
-	Update(&context, (boost::uint8_t*) ByteArray::data(inputCopy), inputCopy.size());
+	Update(&context, (boost::uint8_t*) vecptr(inputCopy), inputCopy.size());
 	return *this;
 }
 
@@ -193,7 +193,7 @@ std::vector<unsigned char> SHA1::getHash() const {
 	std::vector<unsigned char> digest;
 	digest.resize(20);
 	CTX contextCopy(context);
-	Final((boost::uint8_t*) ByteArray::data(digest), &contextCopy);
+	Final((boost::uint8_t*) vecptr(digest), &contextCopy);
 	return digest;
 }
 
@@ -201,12 +201,12 @@ ByteArray SHA1::getHash(const ByteArray& input) {
 	CTX context;
 	Init(&context);
 
-	std::vector<unsigned char> inputCopy(input.getVector());
-	Update(&context, (boost::uint8_t*) ByteArray::data(inputCopy), inputCopy.size());
+	std::vector<unsigned char> inputCopy(input);
+	Update(&context, (boost::uint8_t*) vecptr(inputCopy), inputCopy.size());
 
 	ByteArray digest;
 	digest.resize(20);
-	Final((boost::uint8_t*) digest.getData(), &context);
+	Final((boost::uint8_t*) vecptr(digest), &context);
 
 	return digest;
 }
diff --git a/Swiften/StringCodecs/UnitTest/Base64Test.cpp b/Swiften/StringCodecs/UnitTest/Base64Test.cpp
index 211e684..d1ad5d7 100644
--- a/Swiften/StringCodecs/UnitTest/Base64Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/Base64Test.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/StringCodecs/Base64.h>
 
 using namespace Swift;
@@ -24,12 +25,12 @@ class Base64Test : public CppUnit::TestFixture {
 
 	public:
 		void testEncode() {
-			std::string result(Base64::encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"));
+			std::string result(Base64::encode(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890")));
 			CPPUNIT_ASSERT_EQUAL(std::string("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejEyMzQ1Njc4OTA="), result);
 		}
 
 		void testEncode_NonAscii() {
-			std::string result(Base64::encode(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
+			std::string result(Base64::encode(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
 			CPPUNIT_ASSERT_EQUAL(std::string("QgayPKawpkPSDYmwT/WM94uAlu0="), result);
 		}
 
@@ -40,7 +41,7 @@ class Base64Test : public CppUnit::TestFixture {
 
 		void testDecode() {
 			ByteArray result(Base64::decode("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejEyMzQ1Njc4OTA="));
-			CPPUNIT_ASSERT_EQUAL(ByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), result);
 		}
 
 		void testDecode_NoData() {
diff --git a/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp b/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp
index 600765a..efb613f 100644
--- a/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/StringCodecs/HMACSHA1.h>
 
@@ -21,8 +22,8 @@ class HMACSHA1Test : public CppUnit::TestFixture {
 
 	public:
 		void testGetResult() {
-			ByteArray result(HMACSHA1::getResult("foo", "foobar"));
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xa4\xee\xba\x8e\x63\x3d\x77\x88\x69\xf5\x68\xd0\x5a\x1b\x3d\xc7\x2b\xfd\x4\xdd"), result);
+			ByteArray result(HMACSHA1::getResult(createByteArray("foo"), createByteArray("foobar")));
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xa4\xee\xba\x8e\x63\x3d\x77\x88\x69\xf5\x68\xd0\x5a\x1b\x3d\xc7\x2b\xfd\x4\xdd"), result);
 		}
 };
 
diff --git a/Swiften/StringCodecs/UnitTest/HexifyTest.cpp b/Swiften/StringCodecs/UnitTest/HexifyTest.cpp
index 9643d00..9cbd0d4 100644
--- a/Swiften/StringCodecs/UnitTest/HexifyTest.cpp
+++ b/Swiften/StringCodecs/UnitTest/HexifyTest.cpp
@@ -21,7 +21,7 @@ class HexifyTest : public CppUnit::TestFixture {
 
 	public:
 		void testHexify() {
-			CPPUNIT_ASSERT_EQUAL(std::string("4206b23ca6b0a643d20d89b04ff58cf78b8096ed"), Hexify::hexify(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
+			CPPUNIT_ASSERT_EQUAL(std::string("4206b23ca6b0a643d20d89b04ff58cf78b8096ed"), Hexify::hexify(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
 		}
 
 		void testHexify_Byte() {
diff --git a/Swiften/StringCodecs/UnitTest/MD5Test.cpp b/Swiften/StringCodecs/UnitTest/MD5Test.cpp
index 3f764d2..c66d422 100644
--- a/Swiften/StringCodecs/UnitTest/MD5Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/MD5Test.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/StringCodecs/MD5.h>
 #include <Swiften/Base/ByteArray.h>
 
@@ -22,15 +23,15 @@ class MD5Test : public CppUnit::TestFixture {
 
 	public:
 		void testGetHash_Empty() {
-			ByteArray result(MD5::getHash(""));
+			ByteArray result(MD5::getHash(createByteArray("")));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e", 16), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e", 16), result);
 		}
 
 		void testGetHash_Alphabet() {
-			ByteArray result(MD5::getHash("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"));
+			ByteArray result(MD5::getHash(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d\x9f", 16), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d\x9f", 16), result);
 		}
 };
 
diff --git a/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp b/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp
index 7952471..ae55ac8 100644
--- a/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/StringCodecs/PBKDF2.h>
 
@@ -23,21 +24,21 @@ class PBKDF2Test : public CppUnit::TestFixture {
 
 	public:
 		void testGetResult_I1() {
-			ByteArray result(PBKDF2::encode("password", "salt", 1));
+			ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 1));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6"), result);
 		}
 
 		void testGetResult_I2() {
-			ByteArray result(PBKDF2::encode("password", "salt", 2));
+			ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 2));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xea\x6c\x1\x4d\xc7\x2d\x6f\x8c\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xea\x6c\x1\x4d\xc7\x2d\x6f\x8c\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57"), result);
 		}
 
 		void testGetResult_I4096() {
-			ByteArray result(PBKDF2::encode("password", "salt", 4096));
+			ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 4096));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x4b\x00\x79\x1\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1", 20), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x4b\x00\x79\x1\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1", 20), result);
 		}
 };
 
diff --git a/Swiften/StringCodecs/UnitTest/SHA1Test.cpp b/Swiften/StringCodecs/UnitTest/SHA1Test.cpp
index 76b71f9..004b646 100644
--- a/Swiften/StringCodecs/UnitTest/SHA1Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/SHA1Test.cpp
@@ -9,6 +9,7 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
+#include <QA/Checker/IO.h>
 #include <Swiften/StringCodecs/SHA1.h>
 
 using namespace Swift;
@@ -28,36 +29,36 @@ class SHA1Test : public CppUnit::TestFixture {
 	public:
 		void testGetHash() {
 			SHA1 sha;
-			sha.update(ByteArray::create("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray::create("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
 		}
 
 		void testGetHash_TwoUpdates() {
 			SHA1 sha;
-			sha.update(ByteArray::create("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));
-			sha.update(ByteArray::create("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));
+			sha.update(createByteArray("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray::create("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
 		}
 
 		void testGetHash_TwoGetHash() {
 			SHA1 sha;
-			sha.update(ByteArray::create("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
 
 			sha.getHash();
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray::create("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
 		}
 
 		void testGetHash_InterleavedUpdate() {
 			SHA1 sha;
 
-			sha.update(ByteArray::create("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));
 			sha.getHash();
-			sha.update(ByteArray::create("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+			sha.update(createByteArray("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray::create("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
 		}
 
 
@@ -65,27 +66,27 @@ class SHA1Test : public CppUnit::TestFixture {
 			SHA1 sha;
 			sha.update(std::vector<unsigned char>());
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray::create("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), sha.getHash());
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), sha.getHash());
 		}
 
 		void testGetHashStatic() {
-			ByteArray result(SHA1::getHash("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
+			ByteArray result(SHA1::getHash(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<")));
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
 		}
 
 
 		void testGetHashStatic_Twice() {
-			ByteArray input("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<");
+			ByteArray input(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
 			SHA1::getHash(input);
 			ByteArray result(SHA1::getHash(input));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
 		}
 
 		void testGetHashStatic_NoData() {
 			ByteArray result(SHA1::getHash(ByteArray()));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), result);
 		}
 };
 
diff --git a/Swiften/TLS/Certificate.cpp b/Swiften/TLS/Certificate.cpp
index ecd7d5e..a796463 100644
--- a/Swiften/TLS/Certificate.cpp
+++ b/Swiften/TLS/Certificate.cpp
@@ -22,7 +22,7 @@ Certificate::~Certificate() {
 std::string Certificate::getSHA1Fingerprint() const {
 	ByteArray hash = SHA1::getHash(toDER());
 	std::ostringstream s;
-	for (size_t i = 0; i < hash.getSize(); ++i) {
+	for (size_t i = 0; i < hash.size(); ++i) {
 		if (i > 0) {
 			s << ":";
 		}
diff --git a/Swiften/TLS/OpenSSL/OpenSSLCertificate.cpp b/Swiften/TLS/OpenSSL/OpenSSLCertificate.cpp
index 0b2df5b..06ce360 100644
--- a/Swiften/TLS/OpenSSL/OpenSSLCertificate.cpp
+++ b/Swiften/TLS/OpenSSL/OpenSSLCertificate.cpp
@@ -23,11 +23,11 @@ OpenSSLCertificate::OpenSSLCertificate(boost::shared_ptr<X509> cert) : cert(cert
 
 OpenSSLCertificate::OpenSSLCertificate(const ByteArray& der) {
 #if OPENSSL_VERSION_NUMBER <= 0x009070cfL
-	unsigned char* p = const_cast<unsigned char*>(der.getData());
+	unsigned char* p = const_cast<unsigned char*>(vecptr(der));
 #else
-	const unsigned char* p = der.getData();
+	const unsigned char* p = vecptr(der);
 #endif
-	cert = boost::shared_ptr<X509>(d2i_X509(NULL, &p, der.getSize()), X509_free);
+	cert = boost::shared_ptr<X509>(d2i_X509(NULL, &p, der.size()), X509_free);
 	if (!cert) {
 		SWIFT_LOG(warning) << "Error creating certificate from DER data" << std::endl;
 	}
@@ -41,7 +41,7 @@ ByteArray OpenSSLCertificate::toDER() const {
 
 	ByteArray result;
 	result.resize(i2d_X509(cert.get(), NULL));
-	unsigned char* p = reinterpret_cast<unsigned char*>(result.getData());
+	unsigned char* p = vecptr(result);
 	i2d_X509(cert.get(), &p);
 	return result;
 }
@@ -57,15 +57,15 @@ void OpenSSLCertificate::parse() {
 		// Subject name
 		ByteArray subjectNameData;
 		subjectNameData.resize(256);
-		X509_NAME_oneline(X509_get_subject_name(cert.get()), reinterpret_cast<char*>(subjectNameData.getData()), subjectNameData.getSize());
-		this->subjectName = std::string(reinterpret_cast<const char*>(subjectNameData.getData()));
+		X509_NAME_oneline(X509_get_subject_name(cert.get()), reinterpret_cast<char*>(vecptr(subjectNameData)), subjectNameData.size());
+		this->subjectName = byteArrayToString(subjectNameData);
 
 		// Common name
 		int cnLoc = X509_NAME_get_index_by_NID(subjectName, NID_commonName, -1);
 		while (cnLoc != -1) {
 			X509_NAME_ENTRY* cnEntry = X509_NAME_get_entry(subjectName, cnLoc);
 			ASN1_STRING* cnData = X509_NAME_ENTRY_get_data(cnEntry);
-			commonNames.push_back(ByteArray(cnData->data, cnData->length).toString());
+			commonNames.push_back(byteArrayToString(createByteArray(reinterpret_cast<const char*>(cnData->data), cnData->length)));
 			cnLoc = X509_NAME_get_index_by_NID(subjectName, NID_commonName, cnLoc);
 		}
 	}
@@ -87,7 +87,7 @@ void OpenSSLCertificate::parse() {
 						continue;
 					}
 					ASN1_UTF8STRING* xmppAddrValue = otherName->value->value.utf8string;
-					addXMPPAddress(ByteArray(ASN1_STRING_data(xmppAddrValue), ASN1_STRING_length(xmppAddrValue)).toString());
+					addXMPPAddress(byteArrayToString(createByteArray(reinterpret_cast<const char*>(ASN1_STRING_data(xmppAddrValue)), ASN1_STRING_length(xmppAddrValue))));
 				}
 				else if (OBJ_cmp(otherName->type_id, dnsSRVObject.get()) == 0) {
 					// SRVName
@@ -95,12 +95,12 @@ void OpenSSLCertificate::parse() {
 						continue;
 					}
 					ASN1_IA5STRING* srvNameValue = otherName->value->value.ia5string;
-					addSRVName(ByteArray(ASN1_STRING_data(srvNameValue), ASN1_STRING_length(srvNameValue)).toString());
+					addSRVName(byteArrayToString(createByteArray(reinterpret_cast<const char*>(ASN1_STRING_data(srvNameValue)), ASN1_STRING_length(srvNameValue))));
 				}
 			}
 			else if (generalName->type == GEN_DNS) {
 				// DNSName
-				addDNSName(ByteArray(ASN1_STRING_data(generalName->d.dNSName), ASN1_STRING_length(generalName->d.dNSName)).toString());
+				addDNSName(byteArrayToString(createByteArray(ASN1_STRING_data(generalName->d.dNSName), ASN1_STRING_length(generalName->d.dNSName))));
 			}
 		}
 	}
diff --git a/Swiften/TLS/OpenSSL/OpenSSLContext.cpp b/Swiften/TLS/OpenSSL/OpenSSLContext.cpp
index a2f97e6..edd1503 100644
--- a/Swiften/TLS/OpenSSL/OpenSSLContext.cpp
+++ b/Swiften/TLS/OpenSSL/OpenSSLContext.cpp
@@ -48,8 +48,7 @@ OpenSSLContext::OpenSSLContext() : state_(Start), context_(0), handle_(0), readB
 			if (!certContext) {
 				break;
 			}
-			ByteArray certData(certContext->pbCertEncoded, certContext->cbCertEncoded);
-			OpenSSLCertificate cert(certData);
+			OpenSSLCertificate cert(createByteArray(certContext->pbCertEncoded, certContext->cbCertEncoded));
 			if (store && cert.getInternalX509()) {
 				X509_STORE_add_cert(store, cert.getInternalX509().get());
 			}
@@ -140,13 +139,13 @@ void OpenSSLContext::sendPendingDataToNetwork() {
 	if (size > 0) {
 		ByteArray data;
 		data.resize(size);
-		BIO_read(writeBIO_, data.getData(), size);
+		BIO_read(writeBIO_, vecptr(data), size);
 		onDataForNetwork(data);
 	}
 }
 
 void OpenSSLContext::handleDataFromNetwork(const ByteArray& data) {
-	BIO_write(readBIO_, data.getData(), data.getSize());
+	BIO_write(readBIO_, vecptr(data), data.size());
 	switch (state_) {
 		case Connecting:
 			doConnect();
@@ -160,7 +159,7 @@ void OpenSSLContext::handleDataFromNetwork(const ByteArray& data) {
 }
 
 void OpenSSLContext::handleDataFromApplication(const ByteArray& data) {
-	if (SSL_write(handle_, data.getData(), data.getSize()) >= 0) {
+	if (SSL_write(handle_, vecptr(data), data.size()) >= 0) {
 		sendPendingDataToNetwork();
 	}
 	else {
@@ -172,12 +171,12 @@ void OpenSSLContext::handleDataFromApplication(const ByteArray& data) {
 void OpenSSLContext::sendPendingDataToApplication() {
 	ByteArray data;
 	data.resize(SSL_READ_BUFFERSIZE);
-	int ret = SSL_read(handle_, data.getData(), data.getSize());
+	int ret = SSL_read(handle_, vecptr(data), data.size());
 	while (ret > 0) {
 		data.resize(ret);
 		onDataForApplication(data);
 		data.resize(SSL_READ_BUFFERSIZE);
-		ret = SSL_read(handle_, data.getData(), data.getSize());
+		ret = SSL_read(handle_, vecptr(data), data.size());
 	}
 	if (ret < 0 && SSL_get_error(handle_, ret) != SSL_ERROR_WANT_READ) {
 		state_ = Error;
@@ -192,7 +191,7 @@ bool OpenSSLContext::setClientCertificate(const PKCS12Certificate& certificate)
 
 	// Create a PKCS12 structure
 	BIO* bio = BIO_new(BIO_s_mem());
-	BIO_write(bio, certificate.getData().getData(), certificate.getData().getSize());
+	BIO_write(bio, vecptr(certificate.getData()), certificate.getData().size());
 	boost::shared_ptr<PKCS12> pkcs12(d2i_PKCS12_bio(bio, NULL), PKCS12_free);
 	BIO_free(bio);
 	if (!pkcs12) {
@@ -247,7 +246,7 @@ boost::shared_ptr<CertificateVerificationError> OpenSSLContext::getPeerCertifica
 ByteArray OpenSSLContext::getFinishMessage() const {
 	ByteArray data;
 	data.resize(MAX_FINISHED_SIZE);
-	size_t size = SSL_get_finished(handle_, data.getData(), data.getSize());
+	size_t size = SSL_get_finished(handle_, vecptr(data), data.size());
 	data.resize(size);
 	return data;
 }
diff --git a/Swiften/TLS/PKCS12Certificate.h b/Swiften/TLS/PKCS12Certificate.h
index c5b93ca..d4cb367 100644
--- a/Swiften/TLS/PKCS12Certificate.h
+++ b/Swiften/TLS/PKCS12Certificate.h
@@ -14,11 +14,11 @@ namespace Swift {
 			PKCS12Certificate() {}
 
 			PKCS12Certificate(const std::string& filename, const std::string& password) : password_(password) {
-				data_.readFromFile(filename);
+				readByteArrayFromFile(data_, filename);
 			}
 
 			bool isNull() const {
-				return data_.isEmpty();
+				return data_.empty();
 			}
 
 			const ByteArray& getData() const {
diff --git a/Swiften/TLS/UnitTest/CertificateTest.cpp b/Swiften/TLS/UnitTest/CertificateTest.cpp
index 216aaae..5df5639 100644
--- a/Swiften/TLS/UnitTest/CertificateTest.cpp
+++ b/Swiften/TLS/UnitTest/CertificateTest.cpp
@@ -23,7 +23,7 @@ class CertificateTest : public CppUnit::TestFixture {
 	public:
 		void testGetSHA1Fingerprint() {
 			SimpleCertificate::ref testling = boost::make_shared<SimpleCertificate>();
-			testling->setDER(ByteArray("abcdefg"));
+			testling->setDER(createByteArray("abcdefg"));
 
 			CPPUNIT_ASSERT_EQUAL(std::string("2f:b5:e1:34:19:fc:89:24:68:65:e7:a3:24:f4:76:ec:62:4e:87:40"), testling->getSHA1Fingerprint());
 		}
diff --git a/Swiften/VCards/VCardStorage.cpp b/Swiften/VCards/VCardStorage.cpp
index 6868813..900f1e5 100644
--- a/Swiften/VCards/VCardStorage.cpp
+++ b/Swiften/VCards/VCardStorage.cpp
@@ -16,7 +16,7 @@ VCardStorage::~VCardStorage() {
 
 std::string VCardStorage::getPhotoHash(const JID& jid) const {
 	VCard::ref vCard = getVCard(jid);
-	if (vCard && !vCard->getPhoto().isEmpty()) {
+	if (vCard && !vCard->getPhoto().empty()) {
 		return Hexify::hexify(SHA1::getHash(vCard->getPhoto()));
 	}
 	else {
diff --git a/Swiftob/Storage.cpp b/Swiftob/Storage.cpp
index aac720c..47d0619 100644
--- a/Swiftob/Storage.cpp
+++ b/Swiftob/Storage.cpp
@@ -23,8 +23,8 @@ Storage::Storage(const boost::filesystem::path& path) : settingsPath_(path) {
 void Storage::load() {
 	if (boost::filesystem::exists(settingsPath_)) {
 		Swift::ByteArray data;
-		data.readFromFile(settingsPath_.string());
-		foreach (std::string line, Swift::String::split(data.toString(), '\n')) {
+		Swift::readByteArrayFromFile(data, settingsPath_.string());
+		foreach (std::string line, Swift::String::split(Swift::byteArrayToString(data), '\n')) {
 			std::pair<std::string, std::string> pair = Swift::String::getSplittedAtFirst(line, '\t');
 			settings_[pair.first] = pair.second;
 		}
-- 
cgit v0.10.2-6-g49f6