drinkingtea/ox
2
0
Fork 0
Code Issues Pull Requests Actions Releases Wiki Activity

Cleanup endianess converion redundancy

Browse Source
This commit is contained in:
Gary Talent
2017-04-09 23:28:58 -05:00
parent 8e9a3e91df
commit 31396a071c
4 changed files with 51 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ox/fs/filestore.hpp
+24 -24
View File
@@ -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
+8 -36
View File
@@ -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
+14 -14
View File
@@ -40,19 +40,19 @@ add_executable(
target_link_libraries(ByteSwapTest OxStd)
add_test("Test\\ littleEndianToNative\\ 0x00ff" ByteSwapTest littleEndianToNative<uint16_t> 0x00ff)
add_test("Test\\ littleEndianToNative\\ 0xff00" ByteSwapTest littleEndianToNative<uint16_t> 0xff00)
add_test("Test\\ bigEndianAdapt\\ 0x00ff" ByteSwapTest bigEndianAdapt<uint16_t> 0x00ff)
add_test("Test\\ bigEndianAdapt\\ 0xff00" ByteSwapTest bigEndianAdapt<uint16_t> 0xff00)
add_test("Test\\ littleEndianToNative\\ 0x000000ff" ByteSwapTest littleEndianToNative<uint32_t> 0x000000ff)
add_test("Test\\ littleEndianToNative\\ 0x0000ff00" ByteSwapTest littleEndianToNative<uint32_t> 0x0000ff00)
add_test("Test\\ littleEndianToNative\\ 0x00ff0000" ByteSwapTest littleEndianToNative<uint32_t> 0x00ff0000)
add_test("Test\\ littleEndianToNative\\ 0xff000000" ByteSwapTest littleEndianToNative<uint32_t> 0xff000000)
add_test("Test\\ bigEndianAdapt\\ 0x000000ff" ByteSwapTest bigEndianAdapt<uint32_t> 0x000000ff)
add_test("Test\\ bigEndianAdapt\\ 0x0000ff00" ByteSwapTest bigEndianAdapt<uint32_t> 0x0000ff00)
add_test("Test\\ bigEndianAdapt\\ 0x00ff0000" ByteSwapTest bigEndianAdapt<uint32_t> 0x00ff0000)
add_test("Test\\ bigEndianAdapt\\ 0xff000000" ByteSwapTest bigEndianAdapt<uint32_t> 0xff000000)
add_test("Test\\ littleEndianToNative\\ 0x00000000000000ff" ByteSwapTest littleEndianToNative<uint64_t> 0x00000000000000ff)
add_test("Test\\ littleEndianToNative\\ 0x000000000000ff00" ByteSwapTest littleEndianToNative<uint64_t> 0x000000000000ff00)
add_test("Test\\ littleEndianToNative\\ 0x0000000000ff0000" ByteSwapTest littleEndianToNative<uint64_t> 0x0000000000ff0000)
add_test("Test\\ littleEndianToNative\\ 0x00000000ff000000" ByteSwapTest littleEndianToNative<uint64_t> 0x00000000ff000000)
add_test("Test\\ littleEndianToNative\\ 0x000000ff00000000" ByteSwapTest littleEndianToNative<uint64_t> 0x000000ff00000000)
add_test("Test\\ littleEndianToNative\\ 0x0000ff0000000000" ByteSwapTest littleEndianToNative<uint64_t> 0x0000ff0000000000)
add_test("Test\\ littleEndianToNative\\ 0x00ff000000000000" ByteSwapTest littleEndianToNative<uint64_t> 0x00ff000000000000)
add_test("Test\\ littleEndianToNative\\ 0xff00000000000000" ByteSwapTest littleEndianToNative<uint64_t> 0xff00000000000000)
add_test("Test\\ bigEndianAdapt\\ 0x00000000000000ff" ByteSwapTest bigEndianAdapt<uint64_t> 0x00000000000000ff)
add_test("Test\\ bigEndianAdapt\\ 0x000000000000ff00" ByteSwapTest bigEndianAdapt<uint64_t> 0x000000000000ff00)
add_test("Test\\ bigEndianAdapt\\ 0x0000000000ff0000" ByteSwapTest bigEndianAdapt<uint64_t> 0x0000000000ff0000)
add_test("Test\\ bigEndianAdapt\\ 0x00000000ff000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x00000000ff000000)
add_test("Test\\ bigEndianAdapt\\ 0x000000ff00000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x000000ff00000000)
add_test("Test\\ bigEndianAdapt\\ 0x0000ff0000000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x0000ff0000000000)
add_test("Test\\ bigEndianAdapt\\ 0x00ff000000000000" ByteSwapTest bigEndianAdapt<uint64_t> 0x00ff000000000000)
add_test("Test\\ bigEndianAdapt\\ 0xff00000000000000" ByteSwapTest bigEndianAdapt<uint64_t> 0xff00000000000000)
src/ox/std/test/byteswap_test.cpp
+5 -5
View File
@@ -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> },
{ "littleEndianToNative<uint32_t>", testLittleEndianToNative<uint32_t> },
{ "littleEndianToNative<uint64_t>", testLittleEndianToNative<uint64_t> },
{ "bigEndianAdapt<uint16_t>", testBigEndianAdapt<uint16_t> },
{ "bigEndianAdapt<uint32_t>", testBigEndianAdapt<uint32_t> },
{ "bigEndianAdapt<uint64_t>", testBigEndianAdapt<uint64_t> },
},
};