declare packets + commands

src/main.cpp

@@ -2,14 +2,12 @@
 // #include <td/protocol/packet/PacketVisitor.h>
 #include <td/protocol/command/CommandDispatcher.h>
 #include <td/protocol/command/CommandFactory.h>
-#include <td/protocol/command/CommandHandler.h>
 #include <td/protocol/command/CommandSerializer.h>
 #include <td/protocol/command/CommandVisitor.h>
+#include <td/game/GameHistory.h>
 
 class Test : public td::protocol::CommandVisitor {};
 
-class Test2 : public td::protocol::CommandHandler {};
-
 int main(int argc, char** argv) {
 	// Test visitor;
 	// td::protocol::packets::ChatMessage chat{{"coucou"}};

src/td/common/DataBuffer.cpp

@@ -0,0 +1,162 @@
+#include <td/common/DataBuffer.h>
+
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+
+#include <td/misc/Format.h>
+#include <td/misc/Log.h>
+
+namespace td {
+
+DataBuffer::DataBuffer() : m_ReadOffset(0) {}
+
+DataBuffer::DataBuffer(const DataBuffer& other) : m_Buffer(other.m_Buffer), m_ReadOffset(other.m_ReadOffset) {}
+
+DataBuffer::DataBuffer(DataBuffer&& other) : m_Buffer(std::move(other.m_Buffer)), m_ReadOffset(std::move(other.m_ReadOffset)) {}
+
+DataBuffer::DataBuffer(const std::string& str) : m_Buffer(str.begin(), str.end()), m_ReadOffset(0) {}
+
+DataBuffer::DataBuffer(const DataBuffer& other, Data::difference_type offset) : m_ReadOffset(0) {
+	m_Buffer.reserve(other.GetSize() - static_cast<std::size_t>(offset));
+	std::copy(other.m_Buffer.begin() + offset, other.m_Buffer.end(), std::back_inserter(m_Buffer));
+}
+
+DataBuffer& DataBuffer::operator<<(const std::string& str) {
+	std::size_t strlen = str.length() + 1;	// including null character
+	Resize(GetSize() + strlen);
+	std::memcpy(m_Buffer.data() + GetSize() - strlen, str.data(), strlen);
+	return *this;
+}
+
+DataBuffer& DataBuffer::operator<<(const DataBuffer& data) {
+	m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
+	return *this;
+}
+
+DataBuffer& DataBuffer::operator>>(std::string& str) {
+	std::size_t stringSize = strlen(reinterpret_cast<const char*>(m_Buffer.data()) + m_ReadOffset) + 1;	 // including null character
+	str.resize(stringSize);
+	std::copy(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset),
+		m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset + stringSize), str.begin());
+	m_ReadOffset += stringSize;
+	return *this;
+}
+
+DataBuffer& DataBuffer::operator>>(DataBuffer& data) {
+	data.Resize(GetSize() - m_ReadOffset);
+	std::copy(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), m_Buffer.end(), data.begin());
+	m_ReadOffset = m_Buffer.size();
+	return *this;
+}
+
+void DataBuffer::WriteSome(const char* buffer, std::size_t amount) {
+	std::size_t end_pos = m_Buffer.size();
+	m_Buffer.resize(m_Buffer.size() + amount);
+	std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
+}
+
+void DataBuffer::WriteSome(const std::uint8_t* buffer, std::size_t amount) {
+	std::size_t end_pos = m_Buffer.size();
+	m_Buffer.resize(m_Buffer.size() + amount);
+	std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
+}
+
+void DataBuffer::ReadSome(char* buffer, std::size_t amount) {
+	assert(m_ReadOffset + amount <= GetSize());
+	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
+	m_ReadOffset += amount;
+}
+
+
+void DataBuffer::ReadSome(std::uint8_t* buffer, std::size_t amount) {
+	assert(m_ReadOffset + amount <= GetSize());
+	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
+	m_ReadOffset += amount;
+}
+
+
+void DataBuffer::ReadSome(DataBuffer& buffer, std::size_t amount) {
+	assert(m_ReadOffset + amount <= GetSize());
+	buffer.Resize(amount);
+	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer.begin());
+	m_ReadOffset += amount;
+}
+
+
+DataBuffer& DataBuffer::operator=(const DataBuffer& other) {
+	m_Buffer = other.m_Buffer;
+	m_ReadOffset = other.m_ReadOffset;
+	return *this;
+}
+
+DataBuffer& DataBuffer::operator=(DataBuffer&& other) {
+	m_Buffer = std::move(other.m_Buffer);
+	m_ReadOffset = std::move(other.m_ReadOffset);
+	return *this;
+}
+
+void DataBuffer::SetReadOffset(std::size_t pos) {
+	assert(pos <= GetSize());
+	m_ReadOffset = pos;
+}
+
+std::size_t DataBuffer::GetSize() const {
+	return m_Buffer.size();
+}
+
+std::size_t DataBuffer::GetRemaining() const {
+	return m_Buffer.size() - m_ReadOffset;
+}
+
+DataBuffer::iterator DataBuffer::begin() {
+	return m_Buffer.begin();
+}
+
+DataBuffer::iterator DataBuffer::end() {
+	return m_Buffer.end();
+}
+
+DataBuffer::const_iterator DataBuffer::begin() const {
+	return m_Buffer.begin();
+}
+
+DataBuffer::const_iterator DataBuffer::end() const {
+	return m_Buffer.end();
+}
+
+std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer) {
+	for (unsigned char u : buffer)
+		os << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(u) << " ";
+	os << std::dec;
+	return os;
+}
+
+bool DataBuffer::ReadFile(const std::string& fileName) {
+	try {
+		std::ifstream file(fileName, std::istream::binary);
+		std::ostringstream ss;
+		ss << file.rdbuf();
+		const std::string& s = ss.str();
+		m_Buffer = DataBuffer::Data(s.begin(), s.end());
+		m_ReadOffset = 0;
+	} catch (std::exception& e) {
+		utils::LOGE(utils::Format("[IO] Failed to read file %s ! reason : %s", fileName.c_str(), e.what()));
+		return false;
+	}
+	return m_Buffer.size() > 0;
+}
+
+bool DataBuffer::WriteFile(const std::string& fileName) const {
+	try {
+		std::ofstream file(fileName, std::ostream::binary);
+		file.write(reinterpret_cast<const char*>(m_Buffer.data()), static_cast<std::streamsize>(m_Buffer.size()));
+		file.flush();
+	} catch (std::exception& e) {
+		utils::LOGE(utils::Format("[IO] Failed to read file %s ! reason : %s", fileName.c_str(), e.what()));
+		return false;
+	}
+	return true;
+}
+
+}  // namespace td

src/td/common/VarInt.cpp

@@ -0,0 +1,52 @@
+#include <td/common/VarInt.h>
+
+#include <td/common/DataBuffer.h>
+#include <stdexcept>
+
+namespace td {
+
+static constexpr int SEGMENT_BITS = 0x7F;
+static constexpr int CONTINUE_BIT = 0x80;
+
+std::size_t VarInt::GetSerializedLength() const {
+	DataBuffer buffer;
+	buffer << *this;
+	return buffer.GetSize();
+}
+
+DataBuffer& operator<<(DataBuffer& out, const VarInt& var) {
+	std::uint64_t value = var.m_Value;
+	while (true) {
+		if ((value & ~static_cast<std::uint64_t>(SEGMENT_BITS)) == 0) {
+			out << static_cast<std::uint8_t>(value);
+			return out;
+		}
+
+		out << static_cast<std::uint8_t>((value & SEGMENT_BITS) | CONTINUE_BIT);
+
+		value >>= 7;
+	}
+}
+
+DataBuffer& operator>>(DataBuffer& in, VarInt& var) {
+	var.m_Value = 0;
+	unsigned int position = 0;
+	std::uint8_t currentByte;
+
+	while (true) {
+		in.ReadSome(&currentByte, 1);
+		var.m_Value |= static_cast<std::uint64_t>(currentByte & SEGMENT_BITS) << position;
+
+		if ((currentByte & CONTINUE_BIT) == 0)
+			break;
+
+		position += 7;
+
+		if (position >= 8 * sizeof(var.m_Value))
+			throw std::runtime_error("VarInt is too big");
+	}
+
+	return in;
+}
+
+}  // namespace td

src/td/misc/Log.cpp

@@ -0,0 +1,37 @@
+#include <td/misc/Log.h>
+
+
+
+#ifdef TD_ANDROID_LOGGING
+#include <android/log.h>
+#else
+#include <iostream>
+#endif
+
+namespace td {
+namespace utils {
+
+void LOG(const std::string& msg) {
+#ifdef TD_ANDROID_LOGGING
+	__android_log_print(ANDROID_LOG_INFO, "TRACKERS", "%s", msg.c_str());
+#else
+	std::cout << msg << "\n";
+#endif
+}
+
+void LOGD(const std::string& msg) {
+#if !defined(NDEBUG)
+	LOG(msg);
+#endif
+}
+
+void LOGE(const std::string& err) {
+#ifdef TD_ANDROID_LOGGING
+	__android_log_print(ANDROID_LOG_ERROR, "TRACKERS", "%s", err.c_str());
+#else
+	std::cerr << err << "\n";
+#endif
+}
+
+}  // namespace utils
+}  // namespace td