Add support for DBBitArray to reader struct + parsers

Author: mateofio

src/lcf/reader_lcf.h

@@ -13,6 +13,7 @@
 #include "lcf/config.h"
 #include "lcf/dbstring.h"
 #include "lcf/dbarray.h"
+#include "lcf/dbbitarray.h"
 
 #include <string>
 #include <vector>
@@ -135,6 +136,14 @@ class LcfReader {
 	template <class T>
 	void Read(DBArray<T> &buffer, size_t size);
 
+	/**
+	 * Reads a DBBitsArray of primitive type.
+	 *
+	 * @param buffer DBBitArray to fill.
+	 * @param size how many bytes to read as bits.
+	 */
+	void ReadBits(DBBitArray &buffer, size_t size);
+
 	/**
 	 * Reads a compressed integer from the stream.
 	 *

src/lcf/writer_lcf.h

@@ -12,6 +12,7 @@
 
 #include "lcf/config.h"
 #include "lcf/dbarray.h"
+#include "lcf/dbbitarray.h"
 #include "lcf/dbstring.h"
 
 #include <string>
@@ -71,6 +72,13 @@ class LcfWriter {
 	void Write(const std::string& str);
 	void Write(const DBString& str);
 
+	/**
+	 * Writes a bit array to bytes in the stream.
+	 *
+	 * @param bits the bit array.
+	 */
+	void Write(const DBBitArray& bits);
+
 	/**
 	 * Writes a compressed integer to the stream.
 	 *

src/reader_lcf.cpp

@@ -183,6 +183,14 @@ void LcfReader::ReadVector(ArrayType &buffer, size_t size) {
 	}
 }
 
+void LcfReader::ReadBits(DBBitArray &buffer, size_t size) {
+	buffer = DBBitArray(size);
+	for (size_t i = 0; i < size; ++i) {
+		uint8_t val;
+		Read(&val, sizeof(val), 1);
+		buffer[i] = static_cast<bool>(val);
+	}
+}
 
 void LcfReader::ReadString(std::string& ref, size_t size) {
 	ref.resize(size);
@@ -196,6 +204,8 @@ void LcfReader::ReadString(DBString& ref, size_t size) {
 	ref = DBString(tmp);
 }
 
+
+
 bool LcfReader::IsOk() const {
 	return stream.good() && encoder.IsOk();
 }

src/reader_struct.h

@@ -83,6 +83,7 @@ template <>	struct TypeCategory<bool>							{ static const Category::Index value
 template <>	struct TypeCategory<double>							{ static const Category::Index value = Category::Primitive; };
 template <>	struct TypeCategory<std::string>					{ static const Category::Index value = Category::Primitive; };
 template <>	struct TypeCategory<DBString>						{ static const Category::Index value = Category::Primitive; };
+template <>	struct TypeCategory<DBBitArray>						{ static const Category::Index value = Category::Primitive; };
 
 template <class T>
 struct TypeCategory<std::vector<T>> {
@@ -348,6 +349,37 @@ struct Primitive<DBString> {
 	}
 };
 
+/**
+ * DBBitArray specialization.
+ */
+template <>
+struct Primitive<DBBitArray> {
+	static void ReadLcf(DBBitArray& ref, LcfReader& stream, uint32_t length) {
+		stream.ReadBits(ref, length);
+#ifdef LCF_DEBUG_TRACE
+		printf("  ");
+		for (auto& b: ref) {
+			print("%d", static_cast<int>(b));
+		}
+		printf("\n");
+#endif
+	}
+	static void WriteLcf(const DBBitArray& ref, LcfWriter& stream) {
+		stream.Write(ref);
+	}
+	static int LcfSize(const DBBitArray& ref, LcfWriter& stream) {
+		return ref.size();
+	}
+	static void WriteXml(const DBBitArray& ref, XmlWriter& stream) {
+		stream.Write(ref);
+	}
+	static void ParseXml(DBBitArray& ref, const std::string& data) {
+		XmlReader::Read(ref, data);
+	}
+};
+
+
+
 /**
  * Primitive Reader.
  */

src/reader_xml.cpp

@@ -188,6 +188,14 @@ void XmlReader::Read<DBString>(DBString& val, const std::string& data) {
 	val = DBString(sval);
 }
 
+template <>
+void XmlReader::Read<DBBitArray>(DBBitArray& val, const std::string& data) {
+	// FIXME: Adds copies
+	std::vector<bool> tmp;
+	ReadVector(tmp, data);
+	val = DBBitArray(tmp.begin(), tmp.end());
+}
+
 template <class T>
 void XmlReader::ReadVector(std::vector<T>& val, const std::string& data) {
 	val.clear();

src/writer_lcf.cpp

@@ -158,6 +158,12 @@ void LcfWriter::Write(const DBString& _str) {
 	}
 }
 
+void LcfWriter::Write(const DBBitArray& bits) {
+	for (auto& b: bits) {
+		Write(static_cast<uint8_t>(b));
+	}
+}
+
 uint32_t LcfWriter::Tell() {
 	return (uint32_t)stream.tellp();
 }

src/writer_xml.cpp

@@ -13,6 +13,7 @@
 #include "lcf/writer_xml.h"
 #include "lcf/dbstring.h"
 #include "lcf/dbarray.h"
+#include "lcf/dbbitarray.h"
 
 namespace lcf {
 
@@ -176,6 +177,11 @@ void XmlWriter::WriteInt(int val) {
 	Write<int32_t>(val);
 }
 
+template <>
+void XmlWriter::Write(const DBBitArray& val) {
+	WriteVector(val);
+}
+
 template <typename ArrayType>
 void XmlWriter::WriteVector(const ArrayType& val) {
 	Indent();