Add endianness adapters to OxFS

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 = version;
+	m_version = std::toLittleEndian(version);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 uint16_t FileStoreHeader<FsSize_t, InodeId_t>::getVersion() {
-	return m_version;
+	return std::nativizeLittleEndian(m_version);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setFsType(uint16_t fsType) {
-	m_fsType = fsType;
+	m_fsType = std::toLittleEndian(fsType);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 uint16_t FileStoreHeader<FsSize_t, InodeId_t>::getFsType() {
-	return m_fsType;
+	return std::nativizeLittleEndian(m_fsType);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setSize(FsSize_t size) {
-	m_size = size;
+	m_size = std::toLittleEndian(size);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getSize() {
-	return m_size;
+	return std::nativizeLittleEndian(m_size);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setMemUsed(FsSize_t memUsed) {
-	m_memUsed = memUsed;
+	m_memUsed = std::toLittleEndian(memUsed);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getMemUsed() {
-	return m_memUsed;
+	return std::nativizeLittleEndian(m_memUsed);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setRootInode(FsSize_t rootInode) {
-	m_rootInode = rootInode;
+	m_rootInode = std::toLittleEndian(rootInode);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getRootInode() {
-	return m_rootInode;
+	return std::nativizeLittleEndian(m_rootInode);
 }
 
 template<typename Header>
@@ -121,6 +121,7 @@ class FileStore {
 			public:
 				typename Header::FsSize_t size();
 
+				void setDataLen(typename Header::FsSize_t);
 				typename Header::FsSize_t getDataLen();
 
 				void setPrev(typename Header::FsSize_t);
@@ -315,78 +316,83 @@ class FileStore {
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::size() {
-	return sizeof(Inode) + m_dataLen;
+	return std::nativizeLittleEndian(sizeof(Inode) + getDataLen());
+}
+
+template<typename Header>
+void FileStore<Header>::Inode::setDataLen(typename Header::FsSize_t dataLen) {
+	this->m_dataLen = std::toLittleEndian(dataLen);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getDataLen() {
-	return this->m_dataLen;
+	return std::nativizeLittleEndian(this->m_dataLen);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setPrev(typename Header::FsSize_t prev) {
-	this->m_prev = prev;
+	this->m_prev = std::toLittleEndian(prev);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getPrev() {
-	return this->m_prev;
+	return std::nativizeLittleEndian(this->m_prev);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setNext(typename Header::FsSize_t next) {
-	this->m_next = next;
+	this->m_next = std::toLittleEndian(next);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getNext() {
-	return this->m_next;
+	return std::nativizeLittleEndian(this->m_next);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setId(InodeId_t id) {
-	this->m_id = id;
+	this->m_id = std::toLittleEndian(id);
 }
 
 template<typename Header>
 typename Header::InodeId_t FileStore<Header>::Inode::getId() {
-	return this->m_id;
+	return std::nativizeLittleEndian(this->m_id);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setFileType(uint8_t fileType) {
-	this->m_fileType = fileType;
+	this->m_fileType = std::toLittleEndian(fileType);
 }
 
 template<typename Header>
 uint8_t FileStore<Header>::Inode::getFileType() {
-	return this->m_fileType;
+	return std::nativizeLittleEndian(this->m_fileType);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setLeft(typename Header::FsSize_t left) {
-	this->m_left = left;
+	this->m_left = std::toLittleEndian(left);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getLeft() {
-	return this->m_left;
+	return std::nativizeLittleEndian(this->m_left);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setRight(typename Header::FsSize_t right) {
-	this->m_right = right;
+	this->m_right = std::toLittleEndian(right);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getRight() {
-	return this->m_right;
+	return std::nativizeLittleEndian(this->m_right);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setData(void *data, typename Header::FsSize_t size) {
 	ox_memcpy(this->getData(), data, size);
-	m_dataLen = size;
+	setDataLen(size);
 }
 
 

src/ox/std/CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 2.8)
 
 add_library(
 	OxStd
+		byteswap.cpp
 		memops.cpp
 		strops.cpp
 )

src/ox/std/byteswap.cpp

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2015 - 2017 gtalent2@gmail.com
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include "byteswap.hpp"

src/ox/std/byteswap.hpp

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2015 - 2017 gtalent2@gmail.com
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "types.hpp"
+
+namespace ox {
+namespace std {
+
+inline uint16_t byteSwap(uint16_t i) {
+	return (i << 8) | (i >> 8);
+}
+
+inline uint32_t byteSwap(uint32_t i) {
+	return ((i >> 24) & 0x000000ff) |
+	       ((i >>  8) & 0x0000ff00) |
+	       ((i <<  8) & 0x00ff0000) |
+	       ((i << 24) & 0xff000000);
+}
+
+inline uint64_t byteSwap(uint64_t i) {
+	return ((i >> 56) & 0x00000000000000ff) |
+	       ((i >> 40) & 0x000000000000ff00) |
+	       ((i >> 24) & 0x0000000000ff0000) |
+	       ((i >>  8) & 0x00000000ff000000) |
+	       ((i <<  8) & 0x000000ff00000000) |
+	       ((i << 24) & 0x0000ff0000000000) |
+	       ((i << 40) & 0x00ff000000000000) |
+	       ((i << 56) & 0xff00000000000000);
+}
+
+
+/**
+ * Takes a little endian int and byte swaps if the platform is big endian.
+ */
+inline uint8_t nativizeLittleEndian(uint8_t i) {
+	return i;
+}
+
+/**
+ * Takes a little endian int and byte swaps if the platform is big endian.
+ */
+inline uint16_t nativizeLittleEndian(uint16_t i) {
+#ifdef __BIG_ENDIAN__
+	return byteSwap(i);
+#else
+	return i;
+#endif
+}
+
+/**
+ * Takes a little endian int and byte swaps if the platform is big endian.
+ */
+inline uint32_t nativizeLittleEndian(uint32_t i) {
+#ifdef __BIG_ENDIAN__
+	return byteSwap(i);
+#else
+	return i;
+#endif
+}
+
+/**
+ * Takes a little endian int and byte swaps if the platform is big endian.
+ */
+inline uint64_t nativizeLittleEndian(uint64_t i) {
+#ifdef __BIG_ENDIAN__
+	return byteSwap(i);
+#else
+	return i;
+#endif
+}
+
+
+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
+}
+
+
+inline uint16_t toBigEndian(uint16_t i) {
+#ifdef __LITTLE_ENDIAN__
+	return byteSwap(i);
+#else
+	return i;
+#endif
+}
+
+inline uint32_t toBigEndian(uint32_t i) {
+#ifdef __LITTLE_ENDIAN__
+	return byteSwap(i);
+#else
+	return i;
+#endif
+}
+
+inline uint64_t toBigEndian(uint64_t i) {
+#ifdef __LITTLE_ENDIAN__
+	return byteSwap(i);
+#else
+	return i;
+#endif
+}
+
+}
+}

src/ox/std/std.hpp

@@ -7,6 +7,7 @@
  */
 #pragma once
 
+#include "byteswap.hpp"
 #include "memops.hpp"
 #include "strops.hpp"
 #include "types.hpp"