Initial Working Commit.

CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.18..3.30)
+
+project(Endianness
+    VERSION 1.0
+    LANGUAGES CXX)
+
+if (PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR)
+    message(FATAL_ERROR "In-source builds are not allowed")
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+
+
+file(GLOB_RECURSE HEADERS "include/*.hpp")
+file(GLOB_RECURSE SOURCES "src/*.cpp")
+
+if (UNIX)
+    add_library(Endianness SHARED ${SOURCES})
+endif()
+
+if (WIN32)
+    add_library(Endianness STATIC ${SOURCES})
+endif()
+
+set_target_properties(Endianness PROPERTIES LINKER_LANGUAGE CXX)
+target_include_directories(Endianness PUBLIC ${PROJECT_SOURCE_DIR}/include)
+
+
+add_executable(EndiannessTest main.cpp)
+
+target_link_libraries(EndiannessTest PUBLIC Endianness)

include/Endianness.hpp

@@ -96,7 +96,7 @@ namespace Endianness
 	float HostToNetworkOrder(float host);
 	double HostToNetworkOrder(double host);
 
-	template <typename T> T HostToNetworkOrder(T host) { return HostToNetworkOrder(host);}
+	template <typename T> T HostToNetworkOrder(T host) {throw;}
 
 	template<> inline u16 HostToNetworkOrder<u16>(u16 host) { return HostToNetworkOrder(host);}
 	template<> inline u32 HostToNetworkOrder<u32>(u32 host) { return HostToNetworkOrder(host);}

main.cpp

@@ -1,3 +1,91 @@
 //
 // Created by josh on 6/4/2025.
 //
+
+#include <Endianness.hpp>
+#include <iomanip>
+#include <iostream>
+
+// Template function to perform a round-trip test
+template <typename T>
+void TestRoundTrip(const std::string& type_name, T original_value) {
+    T network_value = Endianness::HostToNetworkOrder(original_value);
+    T host_value = Endianness::NetworkToHostOrder(network_value);
+
+    std::cout << "Testing " << type_name << ": " << std::endl;
+
+    if constexpr (std::is_floating_point_v<T>) {
+        std::cout << "  Original: " << original_value << std::endl;
+        std::cout << "  Network (raw bits): 0x" << std::hex << std::setw(sizeof(T) * 2) << std::setfill('0');
+        if constexpr (std::is_same_v<T, float>) {
+            std::cout << *reinterpret_cast<uint32_t*>(&network_value);
+        } else { // double
+            std::cout << *reinterpret_cast<uint64_t*>(&network_value);
+        }
+        std::cout << std::dec << std::endl;
+        std::cout << "  Host: " << host_value << std::endl;
+    } else {
+        std::cout << "  Original: 0x" << std::hex << original_value << std::dec << std::endl;
+        std::cout << "  Network:  0x" << std::hex << network_value << std::dec << std::endl;
+        std::cout << "  Host:     0x" << std::hex << host_value << std::dec << std::endl;
+    }
+
+
+    if (original_value == host_value) {
+        std::cout << "  Result: SUCCESS" << std::endl;
+    } else {
+        std::cout << "  Result: FAILED - Discrepancy found!" << std::endl;
+    }
+    std::cout << std::endl;
+}
+
+// Template function to test ReverseByteOrder
+template <typename T>
+void TestReverseByteOrder(const std::string& type_name, T original_value) {
+    T reversed_value = Endianness::ReverseByteOrder(original_value);
+
+    std::cout << "Testing ReverseByteOrder for " << type_name << ": " << std::endl;
+    std::cout << "  Original: 0x" << std::hex << original_value << std::dec << std::endl;
+    std::cout << "  Reversed: 0x" << std::hex << reversed_value << std::dec << std::endl;
+    std::cout << std::endl;
+}
+
+// Template function to test ReverseByteOrderIfLittleEndian
+template <typename T>
+void TestReverseByteOrderIfLittleEndian(const std::string& type_name, T original_value) {
+    T conditional_reversed_value = Endianness::ReverseByteOrderIfLittleEndian(original_value);
+
+    std::cout << "Testing ReverseByteOrderIfLittleEndian for " << type_name << ": " << std::endl;
+    std::cout << "  Original: 0x" << std::hex << original_value << std::dec << std::endl;
+    std::cout << "  Conditional Reversed: 0x" << std::hex << conditional_reversed_value << std::dec << std::endl;
+
+    if (Endianness::IsLittleEndian()) {
+        T expected_reversed = Endianness::ReverseByteOrder(original_value);
+        if (conditional_reversed_value == expected_reversed) {
+            std::cout << "  Result (Little Endian Host): SUCCESS (Bytes were reversed)" << std::endl;
+        } else {
+            std::cout << "  Result (Little Endian Host): FAILED (Bytes were NOT reversed as expected)" << std::endl;
+        }
+    } else { // Big Endian
+        if (conditional_reversed_value == original_value) {
+            std::cout << "  Result (Big Endian Host): SUCCESS (No reversal expected)" << std::endl;
+        } else {
+            std::cout << "  Result (Big Endian Host): FAILED (Reversal happened unexpectedly)" << std::endl;
+        }
+    }
+    std::cout << std::endl;
+}
+
+int main()
+{
+	for (int i = 0; i < 256; i++)
+	{
+	    TestRoundTrip("u8", i);
+	    TestRoundTrip("u16", i*i);
+	    TestRoundTrip("u32", i*i*i);
+	    TestRoundTrip("u64", i*i*i*i);
+	}
+
+	return 0;
+
+}

src/Endianness.cpp

@@ -9,20 +9,20 @@
 	#include <socket.h>
 #endif
 
-#include <ReArchive/Endianness.h>
+#include <Endianness.hpp>
 
 namespace Endianness
 {
 
 	// TODO: Manually swap bytes so we can depend less on clunky include directives.
-	u16 HostToNetworkOrder(u16 host)	{ return htons(host); }
+	u16 HostToNetworkOrder(u16 host)	{ return ReverseByteOrderIfLittleEndian(host); }
-	u16 NetworkToHostOrder(u16 network) { return ntohs(network); }
+	u16 NetworkToHostOrder(u16 network) { return ReverseByteOrderIfLittleEndian(network); }
-	s16 HostToNetworkOrder(s16 host)	{ return htons( host); }
+	s16 HostToNetworkOrder(s16 host)	{ return ReverseByteOrderIfLittleEndian( host); }
-	s16 NetworkToHostOrder(s16 network) { return ntohs(network);}
+	s16 NetworkToHostOrder(s16 network) { return ReverseByteOrderIfLittleEndian(network);}
-	u32 HostToNetworkOrder(u32 host)	{ return htonl(host); }
+	u32 HostToNetworkOrder(u32 host)	{ return ReverseByteOrderIfLittleEndian(host); }
-	u32 NetworkToHostOrder(u32 network) { return ntohl(network); }
+	u32 NetworkToHostOrder(u32 network) { return ReverseByteOrderIfLittleEndian(network); }
-	s32 HostToNetworkOrder(s32 host)	{ return htonl(host);}
+	s32 HostToNetworkOrder(s32 host)	{ return ReverseByteOrderIfLittleEndian(host);}
-	s32 NetworkToHostOrder(s32 network) { return ntohl(network);}
+	s32 NetworkToHostOrder(s32 network) { return ReverseByteOrderIfLittleEndian(network);}
 	u64 HostToNetworkOrder(u64 host)	{ return ReverseByteOrderIfLittleEndian(host);    }
 	u64 NetworkToHostOrder(u64 network) { return ReverseByteOrderIfLittleEndian(network); }
 	s64 HostToNetworkOrder(s64 host)	{ return ReverseByteOrderIfLittleEndian(host);    }