Flatten out namespaces to only ox

src/ox/clargs/clargs.cpp

@@ -10,7 +10,6 @@
 #include "clargs.hpp"
 
 namespace ox {
-namespace clargs {
 
 using namespace ::std;
 
@@ -52,4 +51,3 @@ int ClArgs::getInt(const char *arg) {
 }
 
 }
-}

src/ox/clargs/clargs.hpp

@@ -12,7 +12,6 @@
 #include <string>
 
 namespace ox {
-namespace clargs {
 
 class ClArgs {
 	private:
@@ -31,4 +30,3 @@ class ClArgs {
 };
 
 }
-}

src/ox/fs/filestore.hpp

@@ -11,7 +11,6 @@
 #include <ox/std/std.hpp>
 
 namespace ox {
-namespace fs {
 
 template<typename FsT, typename InodeId>
 struct __attribute__((packed)) FileStoreHeader {
@@ -46,52 +45,52 @@ struct __attribute__((packed)) FileStoreHeader {
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setVersion(uint16_t version) {
-	m_version = std::bigEndianAdapt(version);
+	m_version = bigEndianAdapt(version);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 uint16_t FileStoreHeader<FsSize_t, InodeId_t>::getVersion() {
-	return std::bigEndianAdapt(m_version);
+	return bigEndianAdapt(m_version);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setFsType(uint16_t fsType) {
-	m_fsType = std::bigEndianAdapt(fsType);
+	m_fsType = bigEndianAdapt(fsType);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 uint16_t FileStoreHeader<FsSize_t, InodeId_t>::getFsType() {
-	return std::bigEndianAdapt(m_fsType);
+	return bigEndianAdapt(m_fsType);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setSize(FsSize_t size) {
-	m_size = std::bigEndianAdapt(size);
+	m_size = bigEndianAdapt(size);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getSize() {
-	return std::bigEndianAdapt(m_size);
+	return bigEndianAdapt(m_size);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setMemUsed(FsSize_t memUsed) {
-	m_memUsed = std::bigEndianAdapt(memUsed);
+	m_memUsed = bigEndianAdapt(memUsed);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getMemUsed() {
-	return std::bigEndianAdapt(m_memUsed);
+	return bigEndianAdapt(m_memUsed);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 void FileStoreHeader<FsSize_t, InodeId_t>::setRootInode(FsSize_t rootInode) {
-	m_rootInode = std::bigEndianAdapt(rootInode);
+	m_rootInode = bigEndianAdapt(rootInode);
 }
 
 template<typename FsSize_t, typename InodeId_t>
 FsSize_t FileStoreHeader<FsSize_t, InodeId_t>::getRootInode() {
-	return std::bigEndianAdapt(m_rootInode);
+	return bigEndianAdapt(m_rootInode);
 }
 
 template<typename Header>
@@ -368,72 +367,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::bigEndianAdapt(dataLen);
+	this->m_dataLen = bigEndianAdapt(dataLen);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getDataLen() {
-	return std::bigEndianAdapt(m_dataLen);
+	return bigEndianAdapt(m_dataLen);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setPrev(typename Header::FsSize_t prev) {
-	this->m_prev = std::bigEndianAdapt(prev);
+	this->m_prev = bigEndianAdapt(prev);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getPrev() {
-	return std::bigEndianAdapt(m_prev);
+	return bigEndianAdapt(m_prev);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setNext(typename Header::FsSize_t next) {
-	this->m_next = std::bigEndianAdapt(next);
+	this->m_next = bigEndianAdapt(next);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getNext() {
-	return std::bigEndianAdapt(m_next);
+	return bigEndianAdapt(m_next);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setId(InodeId_t id) {
-	this->m_id = std::bigEndianAdapt(id);
+	this->m_id = bigEndianAdapt(id);
 }
 
 template<typename Header>
 typename Header::InodeId_t FileStore<Header>::Inode::getId() {
-	return std::bigEndianAdapt(m_id);
+	return bigEndianAdapt(m_id);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setFileType(uint8_t fileType) {
-	this->m_fileType = std::bigEndianAdapt(fileType);
+	this->m_fileType = bigEndianAdapt(fileType);
 }
 
 template<typename Header>
 uint8_t FileStore<Header>::Inode::getFileType() {
-	return std::bigEndianAdapt(m_fileType);
+	return bigEndianAdapt(m_fileType);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setLeft(typename Header::FsSize_t left) {
-	this->m_left = std::bigEndianAdapt(left);
+	this->m_left = bigEndianAdapt(left);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getLeft() {
-	return std::bigEndianAdapt(m_left);
+	return bigEndianAdapt(m_left);
 }
 
 template<typename Header>
 void FileStore<Header>::Inode::setRight(typename Header::FsSize_t right) {
-	this->m_right = std::bigEndianAdapt(right);
+	this->m_right = bigEndianAdapt(right);
 }
 
 template<typename Header>
 typename Header::FsSize_t FileStore<Header>::Inode::getRight() {
-	return std::bigEndianAdapt(m_right);
+	return bigEndianAdapt(m_right);
 }
 
 template<typename Header>
@@ -852,4 +851,3 @@ typedef FileStore<FileStoreHeader<uint32_t, uint64_t>> FileStore32;
 typedef FileStore<FileStoreHeader<uint64_t, uint64_t>> FileStore64;
 
 }
-}

src/ox/fs/filesystem.cpp

@@ -9,7 +9,6 @@
 #include "filesystem.hpp"
 
 namespace ox {
-namespace fs {
 
 FileSystem *createFileSystem(void *buff, size_t buffSize) {
 	auto version = ((FileStore16*) buff)->version();
@@ -19,13 +18,13 @@ FileSystem *createFileSystem(void *buff, size_t buffSize) {
 	switch (version) {
 		case 5:
 			switch (type) {
-				case ox::fs::OxFS_16:
+				case ox::OxFS_16:
 					fs = new FileSystem16(buff);
 					break;
-				case ox::fs::OxFS_32:
+				case ox::OxFS_32:
 					fs = new FileSystem32(buff);
 					break;
-				case ox::fs::OxFS_64:
+				case ox::OxFS_64:
 					fs = new FileSystem64(buff);
 					break;
 			}
@@ -72,4 +71,3 @@ FileSystem *expandCopyCleanup(FileSystem *fs, size_t size) {
 }
 
 }
-}

src/ox/fs/filesystem.hpp

@@ -12,7 +12,6 @@
 #include "filestore.hpp"
 
 namespace ox {
-namespace fs {
 
 enum FsType {
 	OxFS_16 = 1,
@@ -693,4 +692,3 @@ typedef FileSystemTemplate<FileStore32, OxFS_32> FileSystem32;
 typedef FileSystemTemplate<FileStore64, OxFS_64> FileSystem64;
 
 }
-}

src/ox/fs/oxfstool.cpp

@@ -17,7 +17,7 @@
 #pragma warning(disable:4996)
 #endif
 
-using namespace ox::fs;
+using namespace ox;
 using namespace std;
 
 const static auto oxfstoolVersion = "1.3.0";

src/ox/fs/pathiterator.cpp

@@ -11,7 +11,6 @@
 #include "pathiterator.hpp"
 
 namespace ox {
-namespace fs {
 
 PathIterator::PathIterator(const char *path, size_t maxSize) {
 	m_path = path;
@@ -97,4 +96,3 @@ bool PathIterator::hasNext() {
 }
 
 }
-}

src/ox/fs/pathiterator.hpp

@@ -11,7 +11,6 @@
 #include <ox/std/types.hpp>
 
 namespace ox {
-namespace fs {
 
 class PathIterator {
 	private:
@@ -41,4 +40,3 @@ class PathIterator {
 };
 
 }
-}

src/ox/fs/test/filestore_format.cpp

@@ -7,7 +7,7 @@
  */
 #include <ox/fs/filestore.hpp>
 
-using namespace ox::fs;
+using namespace ox;
 
 int main() {
 	const auto size = 65535;

src/ox/fs/test/filestoreio.cpp

@@ -9,8 +9,7 @@
 #include <ox/std/std.hpp>
 #include <ox/fs/filestore.hpp>
 
-using namespace ox::fs;
+using namespace ox;
-using namespace ox::std;
 
 template<typename FileStore>
 int test() {

src/ox/fs/test/filesystem_format.cpp

@@ -8,8 +8,7 @@
 
 #include <ox/fs/filesystem.hpp>
 
-using namespace ox::fs;
+using namespace ox;
-using namespace ox::std;
 
 template<typename FileSystem>
 int test() {

src/ox/fs/test/tests.cpp

@@ -16,7 +16,7 @@
 #include <ox/std/std.hpp>
 
 using namespace std;
-using namespace ox::fs;
+using namespace ox;
 
 map<string, int(*)(string)> tests = {
 	{

src/ox/mc/read.hpp

@@ -74,7 +74,7 @@ int MetalClawReader::op(const char*, ox::bstring<L> *val) {
 		typedef uint32_t StringLength;
 		size_t size = 0;
 		if (m_buffIt + sizeof(StringLength) < m_buffLen) {
-			size = ox::std::bigEndianAdapt(*((StringLength*) &m_buff[m_buffIt]));
+			size = ox::bigEndianAdapt(*((StringLength*) &m_buff[m_buffIt]));
 			m_buffIt += sizeof(StringLength);
 		} else {
 			err |= MC_BUFFENDED;
@@ -103,7 +103,7 @@ int MetalClawReader::readInteger(I *val) {
 	int err = 0;
 	if (m_fieldPresence.get(m_field)) {
 		if (m_buffIt + sizeof(I) < m_buffLen) {
-			*val = ox::std::bigEndianAdapt(*((I*) &m_buff[m_buffIt]));
+			*val = ox::bigEndianAdapt(*((I*) &m_buff[m_buffIt]));
 			m_buffIt += sizeof(I);
 		} else {
 			err = MC_BUFFENDED;
@@ -123,7 +123,7 @@ int MetalClawReader::op(const char*, T *val, size_t valLen) {
 		typedef uint32_t ArrayLength;
 		size_t len = 0;
 		if (m_buffIt + sizeof(ArrayLength) < m_buffLen) {
-			len = ox::std::bigEndianAdapt(*((T*) &m_buff[m_buffIt]));
+			len = ox::bigEndianAdapt(*((T*) &m_buff[m_buffIt]));
 			m_buffIt += sizeof(ArrayLength);
 		} else {
 			err = MC_BUFFENDED;

src/ox/mc/write.hpp

@@ -62,7 +62,7 @@ int MetalClawWriter::op(const char*, ox::bstring<L> *val) {
 		// write the length
 		typedef uint32_t StringLength;
 		if (m_buffIt + sizeof(StringLength) + val->size() < m_buffLen) {
-			*((StringLength*) &m_buff[m_buffIt]) = ox::std::bigEndianAdapt((StringLength) val->size());
+			*((StringLength*) &m_buff[m_buffIt]) = ox::bigEndianAdapt((StringLength) val->size());
 			m_buffIt += sizeof(StringLength);
 
 			// write the string
@@ -99,7 +99,7 @@ int MetalClawWriter::appendInteger(I val) {
 	bool fieldSet = false;
 	if (val) {
 		if (m_buffIt + sizeof(I) < m_buffLen) {
-			*((I*) &m_buff[m_buffIt]) = ox::std::bigEndianAdapt(val);
+			*((I*) &m_buff[m_buffIt]) = ox::bigEndianAdapt(val);
 			fieldSet = true;
 			m_buffIt += sizeof(I);
 		} else {
@@ -120,7 +120,7 @@ int MetalClawWriter::op(const char*, T *val, size_t len) {
 		// write the length
 		typedef uint32_t ArrayLength;
 		if (m_buffIt + sizeof(ArrayLength) < m_buffLen) {
-			*((T*) &m_buff[m_buffIt]) = ox::std::bigEndianAdapt((ArrayLength) len);
+			*((T*) &m_buff[m_buffIt]) = ox::bigEndianAdapt((ArrayLength) len);
 			m_buffIt += sizeof(ArrayLength);
 		} else {
 			err = MC_BUFFENDED;

src/ox/std/byteswap.hpp

@@ -11,8 +11,6 @@
 #include "types.hpp"
 
 namespace ox {
-namespace std {
-
 
 inline int16_t byteSwap(int16_t i) {
 	return (i << 8) | (i >> 8);
@@ -140,6 +138,4 @@ inline uint64_t bigEndianAdapt(uint64_t i) {
 #endif
 }
 
-
-}
 }

src/ox/std/test/byteswap_test.cpp

@@ -10,7 +10,7 @@
 #include <ox/std/std.hpp>
 
 using namespace std;
-using namespace ox::std;
+using namespace ox;
 
 template<typename T>
 int testBigEndianAdapt(string str) {