Merge branch 'master' of https://git.mtgames.nl/Dreaded_X/io

io/include/io/read.h

@@ -2,6 +2,7 @@
 #include "helper.h"
 #include <iostream>
 #include <vector>
+#include <tuple>
 
 namespace io {
 	// This exists to allow for specialization and clearer errors
@@ -35,19 +36,11 @@ namespace io {
 		return value;
 	}
 
+	template <>
+	float read(std::istream& is);
+
 	template<>
-	size_t read(std::istream& is) {
-		size_t value = 0;
-		uint8_t length = io::read<uint8_t>(is);
-		if (length & 0b10000000) {
-			value = read_bytes<size_t>(is, length & 0b01111111);
-		} else {
-			value = length;
-		}
-		return value;
-	}
-
-
+	size_t read(std::istream& is);
 
 	template <typename T> requires std::is_convertible_v<std::string, T>
 	T read(std::istream& is, size_t length) {

io/include/io/write.h

@@ -31,25 +31,12 @@ namespace io {
 		write_bytes(os, value, sizeof(T));
 	}
 
+	template <>
+	void write(std::ostream& os, float value);
+
 	// Special implementation for size_t (also uint64_t, so maybe this is not that smart)
 	template <>
-	void write(std::ostream& os, size_t value) {
-		// Check if we need more then one byte
-		if (value > 0b01111111) {
-			// Calculate how many bytes we need to store the number
-			uint8_t length = 0;
-			auto x = value;
-			while (x != 0) {
-				x >>= 8;
-				length++;
-			}
-
-			write<uint8_t>(os, length | 0b10000000);
-			write_bytes(os, value, length);
-		} else {
-			write<uint8_t>(os, value);
-		}
-	}
+	void write(std::ostream& os, size_t value);
 
 	template <typename T> requires std::is_convertible_v<T, std::string_view>
 	void write(std::ostream& os, T value, bool store_length = true) {

io/src/read.cpp

@@ -0,0 +1,27 @@
+#include "io/read.h"
+
+namespace io {
+	template<>
+	float read(std::istream& is) {
+		union {
+			uint32_t a;
+			float b;
+		} u;
+
+		u.a = read_bytes<uint32_t>(is, sizeof(uint32_t));
+
+		return u.b;
+	}
+
+	template<>
+	size_t read(std::istream& is) {
+		size_t value = 0;
+		uint8_t length = io::read<uint8_t>(is);
+		if (length & 0b10000000) {
+			value = read_bytes<size_t>(is, length & 0b01111111);
+		} else {
+			value = length;
+		}
+		return value;
+	}
+}

io/src/write.cpp

@@ -1,3 +1,34 @@
 #include "io/write.h"
 
-// We do not implement anything without templates
+namespace io {
+	template<>
+	void write(std::ostream& os, float value) {
+		union {
+			uint32_t a;
+			float b;
+		} u;
+
+		u.b = value;
+		write_bytes(os, u.a, sizeof(uint32_t));
+	}
+
+	// Special implementation for size_t (also uint64_t, so maybe this is not that smart)
+	template<>
+	void write(std::ostream& os, size_t value) {
+		// Check if we need more then one byte
+		if (value > 0b01111111) {
+			// Calculate how many bytes we need to store the number
+			uint8_t length = 0;
+			auto x = value;
+			while (x != 0) {
+				x >>= 8;
+				length++;
+			}
+
+			write<uint8_t>(os, length | 0b10000000);
+			write_bytes(os, value, length);
+		} else {
+			write<uint8_t>(os, value);
+		}
+	}
+}

test/src/test.cpp

@@ -74,6 +74,24 @@ int main() {
 		return io::read<int>(f) == 80085;
 	}());
 
+	Test("Write for float", [] {
+		std::fstream f("test.bin", std::ios::trunc | std::ios::in | std::ios::out);
+		io::write<float>(f, 123.654f);
+
+		bool succes = 4 == f.tellg(); f.seekg(0); char c;
+		f.read(&c,1); succes &= (c & 0xff) == 0x42;
+		f.read(&c,1); succes &= (c & 0xff) == 0xf7;
+		f.read(&c,1); succes &= (c & 0xff) == 0x4e;
+		f.read(&c,1); succes &= (c & 0xff) == 0xd9;
+		return succes;
+	}());
+
+	Test("Read for float", [] {
+		std::ifstream f("test.bin");
+		return io::read<float>(f) == 123.654f;
+	}());
+
+
 	Test("Write for short size_t", [] {
 		std::fstream f("test.bin", std::ios::trunc | std::ios::in | std::ios::out);
 		io::write<size_t>(f, 12);