Cleanup endianess converion redundancy

src/ox/fs/filestore.hpp

@@ -45,52 +45,52 @@ struct FileStoreHeader {
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setVersion(uint16_t version) {
-	m_version = std::toLittleEndian(version);
+	m_version = std::bigEndianAdapt(version);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 uint16_t FileStoreHeader<FsSize_t, InodeId_t>::getVersion() {
-	return std::littleEndianToNative(m_version);
+	return std::bigEndianAdapt(m_version);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setFsType(uint16_t fsType) {
-	m_fsType = std::toLittleEndian(fsType);
+	m_fsType = std::bigEndianAdapt(fsType);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 uint16_t FileStoreHeader<FsSize_t, InodeId_t>::getFsType() {
-	return std::littleEndianToNative(m_fsType);
+	return std::bigEndianAdapt(m_fsType);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setSize(FsSize_t size) {
-	m_size = std::toLittleEndian(size);
+	m_size = std::bigEndianAdapt(size);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getSize() {
-	return std::littleEndianToNative(m_size);
+	return std::bigEndianAdapt(m_size);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setMemUsed(FsSize_t memUsed) {
-	m_memUsed = std::toLittleEndian(memUsed);
+	m_memUsed = std::bigEndianAdapt(memUsed);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getMemUsed() {
-	return std::littleEndianToNative(m_memUsed);
+	return std::bigEndianAdapt(m_memUsed);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setRootInode(FsSize_t rootInode) {
-	m_rootInode = std::toLittleEndian(rootInode);
+	m_rootInode = std::bigEndianAdapt(rootInode);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getRootInode() {
-	return std::littleEndianToNative(m_rootInode);
+	return std::bigEndianAdapt(m_rootInode);
 }
 
 template<typename Header>
@@ -321,72 +321,72 @@ typename Header::FsSize_t FileStore<Header>::Inode::size() {
 
 template<typename Header>
 void FileStore<Header>::Inode::setDataLen(typename Header::FsSize_t dataLen) {
-	this->m_dataLen = std::toLittleEndian(dataLen);
+	this->m_dataLen = std::bigEndianAdapt(dataLen);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getDataLen() {
-	return std::littleEndianToNative(this->m_dataLen);
+	return std::bigEndianAdapt(this->m_dataLen);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setPrev(typename Header::FsSize_t prev) {
-	this->m_prev = std::toLittleEndian(prev);
+	this->m_prev = std::bigEndianAdapt(prev);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getPrev() {
-	return std::littleEndianToNative(this->m_prev);
+	return std::bigEndianAdapt(this->m_prev);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setNext(typename Header::FsSize_t next) {
-	this->m_next = std::toLittleEndian(next);
+	this->m_next = std::bigEndianAdapt(next);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getNext() {
-	return std::littleEndianToNative(this->m_next);
+	return std::bigEndianAdapt(this->m_next);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setId(InodeId_t id) {
-	this->m_id = std::toLittleEndian(id);
+	this->m_id = std::bigEndianAdapt(id);
 }
 
 template<typename Header>
 typename Header::InodeId_t FileStore<Header>::Inode::getId() {
-	return std::littleEndianToNative(this->m_id);
+	return std::bigEndianAdapt(this->m_id);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setFileType(uint8_t fileType) {
-	this->m_fileType = std::toLittleEndian(fileType);
+	this->m_fileType = std::bigEndianAdapt(fileType);
 }
 
 template<typename Header>
 uint8_t FileStore<Header>::Inode::getFileType() {
-	return std::littleEndianToNative(this->m_fileType);
+	return std::bigEndianAdapt(this->m_fileType);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setLeft(typename Header::FsSize_t left) {
-	this->m_left = std::toLittleEndian(left);
+	this->m_left = std::bigEndianAdapt(left);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getLeft() {
-	return std::littleEndianToNative(this->m_left);
+	return std::bigEndianAdapt(this->m_left);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setRight(typename Header::FsSize_t right) {
-	this->m_right = std::toLittleEndian(right);
+	this->m_right = std::bigEndianAdapt(right);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getRight() {
-	return std::littleEndianToNative(this->m_right);
+	return std::bigEndianAdapt(this->m_right);
 }
 
 template<typename Header>

src/ox/std/byteswap.hpp

@@ -38,16 +38,16 @@ inline uint64_t byteSwap(uint64_t i) {
 
 
 /**
- * Takes a little endian int and byte swaps if the platform is big endian.
+ * Takes an int and byte swaps if the platform is big endian.
  */
-inline uint8_t littleEndianToNative(uint8_t i) {
+inline uint8_t bigEndianAdapt(uint8_t i) {
 	return i;
 }
 
 /**
- * Takes a little endian int and byte swaps if the platform is big endian.
+ * Takes an int and byte swaps if the platform is big endian.
  */
-inline uint16_t littleEndianToNative(uint16_t i) {
+inline uint16_t bigEndianAdapt(uint16_t i) {
 #ifdef __BIG_ENDIAN__
 	return byteSwap(i);
 #else
@@ -56,9 +56,9 @@ inline uint16_t littleEndianToNative(uint16_t i) {
 }
 
 /**
- * Takes a little endian int and byte swaps if the platform is big endian.
+ * Takes an int and byte swaps if the platform is big endian.
  */
-inline uint32_t littleEndianToNative(uint32_t i) {
+inline uint32_t bigEndianAdapt(uint32_t i) {
 #ifdef __BIG_ENDIAN__
 	return byteSwap(i);
 #else
@@ -67,9 +67,9 @@ inline uint32_t littleEndianToNative(uint32_t i) {
 }
 
 /**
- * Takes a little endian int and byte swaps if the platform is big endian.
+ * Takes an int and byte swaps if the platform is big endian.
  */
-inline uint64_t littleEndianToNative(uint64_t i) {
+inline uint64_t bigEndianAdapt(uint64_t i) {
 #ifdef __BIG_ENDIAN__
 	return byteSwap(i);
 #else
@@ -78,33 +78,5 @@ inline uint64_t littleEndianToNative(uint64_t i) {
 }
 
 
-inline uint8_t toLittleEndian(uint8_t i) {
-	return i;
-}
-
-inline uint16_t toLittleEndian(uint16_t i) {
-#ifdef __BIG_ENDIAN__
-	return byteSwap(i);
-#else
-	return i;
-#endif
-}
-
-inline uint32_t toLittleEndian(uint32_t i) {
-#ifdef __BIG_ENDIAN__
-	return byteSwap(i);
-#else
-	return i;
-#endif
-}
-
-inline uint64_t toLittleEndian(uint64_t i) {
-#ifdef __BIG_ENDIAN__
-	return byteSwap(i);
-#else
-	return i;
-#endif
-}
-
 }
 }

src/ox/std/test/CMakeLists.txt

@@ -40,19 +40,19 @@ add_executable(
 
 target_link_libraries(ByteSwapTest OxStd)
 
-add_test("Test\\ littleEndianToNative\\ 0x00ff" ByteSwapTest littleEndianToNative<uint16_t> 0x00ff)
+add_test("Test\\ bigEndianAdapt\\ 0x00ff" ByteSwapTest bigEndianAdapt<uint16_t> 0x00ff)
-add_test("Test\\ littleEndianToNative\\ 0xff00" ByteSwapTest littleEndianToNative<uint16_t> 0xff00)
+add_test("Test\\ bigEndianAdapt\\ 0xff00" ByteSwapTest bigEndianAdapt<uint16_t> 0xff00)
 
-add_test("Test\\ littleEndianToNative\\ 0x000000ff" ByteSwapTest littleEndianToNative<uint32_t> 0x000000ff)
+add_test("Test\\ bigEndianAdapt\\ 0x000000ff" ByteSwapTest bigEndianAdapt<uint32_t> 0x000000ff)
-add_test("Test\\ littleEndianToNative\\ 0x0000ff00" ByteSwapTest littleEndianToNative<uint32_t> 0x0000ff00)
+add_test("Test\\ bigEndianAdapt\\ 0x0000ff00" ByteSwapTest bigEndianAdapt<uint32_t> 0x0000ff00)
-add_test("Test\\ littleEndianToNative\\ 0x00ff0000" ByteSwapTest littleEndianToNative<uint32_t> 0x00ff0000)
+add_test("Test\\ bigEndianAdapt\\ 0x00ff0000" ByteSwapTest bigEndianAdapt<uint32_t> 0x00ff0000)
-add_test("Test\\ littleEndianToNative\\ 0xff000000" ByteSwapTest littleEndianToNative<uint32_t> 0xff000000)
+add_test("Test\\ bigEndianAdapt\\ 0xff000000" ByteSwapTest bigEndianAdapt<uint32_t> 0xff000000)
 
-add_test("Test\\ littleEndianToNative\\ 0x00000000000000ff" ByteSwapTest littleEndianToNative<uint64_t> 0x00000000000000ff)
+add_test("Test\\ bigEndianAdapt\\ 0x00000000000000ff" ByteSwapTest bigEndianAdapt<uint64_t> 0x00000000000000ff)
-add_test("Test\\ littleEndianToNative\\ 0x000000000000ff00" ByteSwapTest littleEndianToNative<uint64_t> 0x000000000000ff00)
+add_test("Test\\ bigEndianAdapt\\ 0x000000000000ff00" ByteSwapTest bigEndianAdapt<uint64_t> 0x000000000000ff00)
-add_test("Test\\ littleEndianToNative\\ 0x0000000000ff0000" ByteSwapTest littleEndianToNative<uint64_t> 0x0000000000ff0000)
+add_test("Test\\ bigEndianAdapt\\ 0x0000000000ff0000" ByteSwapTest bigEndianAdapt<uint64_t> 0x0000000000ff0000)
-add_test("Test\\ littleEndianToNative\\ 0x00000000ff000000" ByteSwapTest littleEndianToNative<uint64_t> 0x00000000ff000000)
+add_test("Test\\ bigEndianAdapt\\ 0x00000000ff000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x00000000ff000000)
-add_test("Test\\ littleEndianToNative\\ 0x000000ff00000000" ByteSwapTest littleEndianToNative<uint64_t> 0x000000ff00000000)
+add_test("Test\\ bigEndianAdapt\\ 0x000000ff00000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x000000ff00000000)
-add_test("Test\\ littleEndianToNative\\ 0x0000ff0000000000" ByteSwapTest littleEndianToNative<uint64_t> 0x0000ff0000000000)
+add_test("Test\\ bigEndianAdapt\\ 0x0000ff0000000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x0000ff0000000000)
-add_test("Test\\ littleEndianToNative\\ 0x00ff000000000000" ByteSwapTest littleEndianToNative<uint64_t> 0x00ff000000000000)
+add_test("Test\\ bigEndianAdapt\\ 0x00ff000000000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x00ff000000000000)
-add_test("Test\\ littleEndianToNative\\ 0xff00000000000000" ByteSwapTest littleEndianToNative<uint64_t> 0xff00000000000000)
+add_test("Test\\ bigEndianAdapt\\ 0xff00000000000000" ByteSwapTest bigEndianAdapt<uint64_t> 0xff00000000000000)

src/ox/std/test/byteswap_test.cpp

@@ -14,16 +14,16 @@ using namespace std;
 using namespace ox::std;
 
 template<typename T>
-int testLittleEndianToNative(string str) {
+int testBigEndianAdapt(string str) {
 	auto i = (T) stoul(str, nullptr, 16);
-	return !(littleEndianToNative(littleEndianToNative(i)) == i);
+	return !(bigEndianAdapt(bigEndianAdapt(i)) == i);
 }
 
 map<string, function<int(string)>> tests = {
 	{
-		{ "littleEndianToNative<uint16_t>", testLittleEndianToNative<uint16_t> },
+		{ "bigEndianAdapt<uint16_t>", testBigEndianAdapt<uint16_t> },
-		{ "littleEndianToNative<uint32_t>", testLittleEndianToNative<uint32_t> },
+		{ "bigEndianAdapt<uint32_t>", testBigEndianAdapt<uint32_t> },
-		{ "littleEndianToNative<uint64_t>", testLittleEndianToNative<uint64_t> },
+		{ "bigEndianAdapt<uint64_t>", testBigEndianAdapt<uint64_t> },
 	},
 };