Added memory buffer plus tests to project, going to use it for item serialization

common/CMakeLists.txt

@@ -37,6 +37,7 @@ SET(common_sources
 	item_container.cpp
 	item_instance.cpp
 	md5.cpp
+	memory_buffer.cpp
 	memory_mapped_file.cpp
 	misc.cpp
 	misc_functions.cpp
@@ -152,6 +153,7 @@ SET(common_headers
 	loottable.h
 	mail_oplist.h
 	md5.h
+	memory_buffer.h
 	memory_mapped_file.h
 	misc.h
 	misc_functions.h

common/memory_buffer.cpp

@@ -0,0 +1,171 @@
+#include "memory_buffer.h"
+
+EQEmu::MemoryBuffer::MemoryBuffer() {
+	buffer_ = nullptr;
+	size_ = 0;
+	capacity_ = 0;
+	read_pos_ = 0;
+	write_pos_ = 0;
+}
+
+EQEmu::MemoryBuffer::MemoryBuffer(size_t sz) {
+	buffer_ = nullptr;
+	size_ = 0;
+	capacity_ = 0;
+	read_pos_ = 0;
+	write_pos_ = 0;
+	Resize(sz);
+}
+
+EQEmu::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other) {
+	if(other.capacity_) {
+		buffer_ = new uchar[other.capacity_];
+		memcpy(buffer_, other.buffer_, other.capacity_);
+	} else {
+		buffer_ = nullptr;
+	}
+
+	size_ = other.size_;
+	capacity_ = other.capacity_;
+	write_pos_ = other.write_pos_;
+	read_pos_ = other.read_pos_;
+}
+
+EQEmu::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other) {
+	buffer_ = other.buffer_;
+	size_ = other.size_;
+	capacity_ = other.capacity_;
+	write_pos_ = other.write_pos_;
+	read_pos_ = other.read_pos_;
+
+	other.buffer_ = nullptr;
+	other.size_ = 0;
+	other.capacity_ = 0;
+	other.read_pos_ = 0;
+	other.write_pos_ = 0;
+}
+
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(const MemoryBuffer &other) {
+	if(other.capacity_) {
+		buffer_ = new uchar[other.capacity_];
+		memcpy(buffer_, other.buffer_, other.capacity_);
+	}
+	else {
+		buffer_ = nullptr;
+	}
+
+	size_ = other.size_;
+	capacity_ = other.capacity_;
+	write_pos_ = other.write_pos_;
+	read_pos_ = other.read_pos_;
+	return *this;
+}
+
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(MemoryBuffer &&other) {
+	buffer_ = other.buffer_;
+	size_ = other.size_;
+	capacity_ = other.capacity_;
+	write_pos_ = other.write_pos_;
+	read_pos_ = other.read_pos_;
+
+	other.buffer_ = nullptr;
+	other.size_ = 0;
+	other.capacity_ = 0;
+	other.read_pos_ = 0;
+	other.write_pos_ = 0;
+	return *this;
+}
+
+EQEmu::MemoryBuffer::~MemoryBuffer() { Clear(); }
+
+uchar& EQEmu::MemoryBuffer::operator[](size_t pos) {
+	return buffer_[pos];
+}
+
+const uchar& EQEmu::MemoryBuffer::operator[](size_t pos) const {
+	return buffer_[pos];
+}
+
+bool EQEmu::MemoryBuffer::Empty() {
+	return size_ == 0;
+}
+
+bool EQEmu::MemoryBuffer::Empty() const {
+	return size_ == 0;
+}
+
+size_t EQEmu::MemoryBuffer::Size() {
+	return size_;
+}
+
+size_t EQEmu::MemoryBuffer::Size() const {
+	return size_;
+}
+
+size_t EQEmu::MemoryBuffer::Capacity() {
+	return capacity_;
+}
+
+size_t EQEmu::MemoryBuffer::Capacity() const {
+	return capacity_;
+}
+
+void EQEmu::MemoryBuffer::Resize(size_t sz) {
+	if(!buffer_) {
+		size_t new_size = sz + 32;
+		buffer_ = new uchar[new_size];
+		capacity_ = new_size;
+		size_ = sz;
+		memset(buffer_, 0, capacity_);
+		return;
+	}
+
+	if(sz > capacity_) {
+		size_t new_size = sz + 32;
+		uchar *temp = new uchar[new_size];
+		memcpy(temp, buffer_, new_size);
+		delete[] buffer_;
+		buffer_ = temp;
+		
+		capacity_ = new_size;
+		size_ = sz;
+	}
+	else {
+		size_ = sz;
+	}
+}
+
+void EQEmu::MemoryBuffer::Clear() {
+	if(buffer_) {
+		delete[] buffer_;
+		buffer_ = nullptr;
+	}
+	
+	size_ = 0;
+	capacity_ = 0;
+}
+
+void EQEmu::MemoryBuffer::Zero() {
+	if(buffer_) {
+		memset(buffer_, 0, capacity_);
+	}
+}
+
+void EQEmu::MemoryBuffer::Write(const char *val, size_t len) {
+	size_t size_needed = write_pos_ + len;
+	Resize(size_needed);
+
+	memcpy(&buffer_[write_pos_], val, len);
+	write_pos_ += len;
+}
+
+void EQEmu::MemoryBuffer::Read(uchar *buf, size_t len) {
+	memcpy(buf, &buffer_[read_pos_], len);
+	read_pos_ += len;
+}
+
+void EQEmu::MemoryBuffer::Read(char *str) {
+	size_t len = strlen((const char*)&buffer_[read_pos_]);
+	memcpy(str, &buffer_[read_pos_], len);
+	read_pos_ += len;
+}

common/memory_buffer.h

@@ -0,0 +1,131 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef COMMON_MEMORY_BUFFER_H
+#define COMMON_MEMORY_BUFFER_H
+
+#include "types.h"
+#include <type_traits>
+#include <string.h>
+#include <string>
+
+namespace EQEmu
+{
+	class MemoryBuffer
+	{
+	public:
+		MemoryBuffer();
+		MemoryBuffer(size_t sz);
+		MemoryBuffer(const MemoryBuffer &other);
+		MemoryBuffer(MemoryBuffer &&other);
+		MemoryBuffer& operator=(const MemoryBuffer &other);
+		MemoryBuffer& operator=(MemoryBuffer &&other);
+		~MemoryBuffer();
+		
+		uchar& operator[](size_t pos);
+		const uchar& operator[](size_t pos) const;
+
+		template<typename T>
+		operator T*() {
+			return reinterpret_cast<T*>(buffer_);
+		}
+
+		template<typename T>
+		operator T*() const {
+			return reinterpret_cast<T*>(buffer_);
+		}
+
+		operator bool() { return buffer_ != nullptr; }
+		operator bool() const { return buffer_ != nullptr; }
+
+		bool Empty();
+		bool Empty() const;
+		size_t Size();
+		size_t Size() const;
+		size_t Capacity();
+		size_t Capacity() const;
+		
+		void Resize(size_t sz);
+		void Clear();
+		void Zero();
+
+		template<typename T>
+		void Write(T val) {
+			static_assert(std::is_pod<T>::value, "MemoryBuffer::Write<T>(T val) only works on pod and string types.");
+			Write((const char*)&val, sizeof(T));
+		}
+
+		template<typename T>
+		T Read() {
+			static_assert(std::is_pod<T>::value, "MemoryBuffer::Read<T>() only works on pod and string types.");
+			T temp;
+			Read((uchar*)&temp, sizeof(T));
+			return temp;
+		}
+
+		template<>
+		void Write<std::string>(std::string val) {
+			Write(val.c_str(), val.length());
+			Write((uint8)0);
+		}
+
+		template<>
+		void Write<const std::string&>(const std::string &val) {
+			Write(val.c_str(), val.length());
+			Write((uint8)0);
+		}
+
+		template<>
+		void Write<const char*>(const char *val) {
+			size_t len = strlen(val);
+			Write(val, len);
+			Write((uint8)0);
+		}
+
+		template<>
+		std::string Read<std::string>() {
+			std::string ret;
+			size_t len = strlen((const char*)&buffer_[read_pos_]);
+			ret.resize(len);
+			memcpy(&ret[0], &buffer_[read_pos_], len);
+			read_pos_ += len + 1;
+			return ret;
+		}
+	
+		void Write(const char *val, size_t len);
+		void Read(uchar *buf, size_t len);
+		void Read(char *str);
+
+		inline size_t GetWritePosition() { return write_pos_; }
+		inline void SetWritePosition(size_t wp) { write_pos_ = wp; }
+		inline void WriteSkipBytes(size_t skip) { write_pos_ += skip; }
+		inline size_t GetReadPosition() { return read_pos_; }
+		inline void SetReadPosition(size_t wp) { read_pos_ = wp; }
+		inline void ReadSkipBytes(size_t skip) { read_pos_ += skip; }
+		
+	private:
+		uchar *buffer_;
+		size_t size_;
+		size_t capacity_;
+		size_t write_pos_;
+		size_t read_pos_;
+	};
+
+} // EQEmu
+
+#endif