minor cosmetic updates here and there

Author: eteran

arena/include/cpp-utilities/arena.h

@@ -54,7 +54,7 @@ class malloc_storage {
 		free(p_);
 	}
 
-	malloc_storage(const malloc_storage &) = delete;
+	malloc_storage(const malloc_storage &)            = delete;
 	malloc_storage &operator=(const malloc_storage &) = delete;
 
 	malloc_storage(malloc_storage &&other) noexcept
@@ -86,11 +86,11 @@ class arena_allocator<T, Count, bitset_strategy_tag> {
 		freelist_.set();
 	}
 
-	arena_allocator(arena_allocator &&) noexcept = default;
+	arena_allocator(arena_allocator &&) noexcept            = default;
 	arena_allocator &operator=(arena_allocator &&) noexcept = default;
 	arena_allocator(const arena_allocator &)                = delete;
-	arena_allocator &operator=(const arena_allocator &) = delete;
-	~arena_allocator()                                  = default;
+	arena_allocator &operator=(const arena_allocator &)     = delete;
+	~arena_allocator()                                      = default;
 
 public:
 	void release(void *ptr) noexcept {
@@ -161,7 +161,7 @@ class arena_allocator<T, Count, linked_strategy_tag> {
 	}
 
 private:
-	arena_allocator(const arena_allocator &) = delete;
+	arena_allocator(const arena_allocator &)            = delete;
 	arena_allocator &operator=(const arena_allocator &) = delete;
 
 public:

container/include/cpp-utilities/flat_map.h

@@ -47,7 +47,7 @@ class flat_map {
 		}
 
 	public:
-		// for convinience
+		// for convenience
 		bool operator()(const key_type &lhs, const value_type &rhs) const {
 			return comp(lhs, rhs.first);
 		}

fixed/include/cpp-utilities/fixed.h

@@ -47,7 +47,7 @@ class fixed;
 namespace detail {
 
 // helper templates to make magic with types :)
-// these allow us to determine resonable types from
+// these allow us to determine reasonable types from
 // a desired size, they also let us infer the next largest type
 // from a type which is nice for the division op
 template <size_t T>
@@ -284,8 +284,8 @@ class fixed {
 	static constexpr base_type one = base_type(1) << fractional_bits;
 
 public: // constructors
-	fixed()              = default;
-	fixed(const fixed &) = default;
+	fixed()                         = default;
+	fixed(const fixed &)            = default;
 	fixed &operator=(const fixed &) = default;
 
 	template <class Number>
@@ -538,16 +538,19 @@ CONSTEXPR14 fixed<I, F> operator+(fixed<I, F> lhs, fixed<I, F> rhs) {
 	lhs += rhs;
 	return lhs;
 }
+
 template <size_t I, size_t F>
 CONSTEXPR14 fixed<I, F> operator-(fixed<I, F> lhs, fixed<I, F> rhs) {
 	lhs -= rhs;
 	return lhs;
 }
+
 template <size_t I, size_t F>
 CONSTEXPR14 fixed<I, F> operator*(fixed<I, F> lhs, fixed<I, F> rhs) {
 	lhs *= rhs;
 	return lhs;
 }
+
 template <size_t I, size_t F>
 CONSTEXPR14 fixed<I, F> operator/(fixed<I, F> lhs, fixed<I, F> rhs) {
 	lhs /= rhs;
@@ -559,16 +562,19 @@ CONSTEXPR14 fixed<I, F> operator+(fixed<I, F> lhs, Number rhs) {
 	lhs += fixed<I, F>(rhs);
 	return lhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 CONSTEXPR14 fixed<I, F> operator-(fixed<I, F> lhs, Number rhs) {
 	lhs -= fixed<I, F>(rhs);
 	return lhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 CONSTEXPR14 fixed<I, F> operator*(fixed<I, F> lhs, Number rhs) {
 	lhs *= fixed<I, F>(rhs);
 	return lhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 CONSTEXPR14 fixed<I, F> operator/(fixed<I, F> lhs, Number rhs) {
 	lhs /= fixed<I, F>(rhs);
@@ -581,18 +587,21 @@ CONSTEXPR14 fixed<I, F> operator+(Number lhs, fixed<I, F> rhs) {
 	tmp += rhs;
 	return tmp;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 CONSTEXPR14 fixed<I, F> operator-(Number lhs, fixed<I, F> rhs) {
 	fixed<I, F> tmp(lhs);
 	tmp -= rhs;
 	return tmp;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 CONSTEXPR14 fixed<I, F> operator*(Number lhs, fixed<I, F> rhs) {
 	fixed<I, F> tmp(lhs);
 	tmp *= rhs;
 	return tmp;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 CONSTEXPR14 fixed<I, F> operator/(Number lhs, fixed<I, F> rhs) {
 	fixed<I, F> tmp(lhs);
@@ -606,6 +615,7 @@ CONSTEXPR14 fixed<I, F> operator<<(fixed<I, F> lhs, Integer rhs) {
 	lhs <<= rhs;
 	return lhs;
 }
+
 template <size_t I, size_t F, class Integer, class = typename std::enable_if<std::is_integral<Integer>::value>::type>
 CONSTEXPR14 fixed<I, F> operator>>(fixed<I, F> lhs, Integer rhs) {
 	lhs >>= rhs;
@@ -617,22 +627,27 @@ template <size_t I, size_t F, class Number, class = typename std::enable_if<std:
 constexpr bool operator>(fixed<I, F> lhs, Number rhs) {
 	return lhs > fixed<I, F>(rhs);
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<(fixed<I, F> lhs, Number rhs) {
 	return lhs < fixed<I, F>(rhs);
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator>=(fixed<I, F> lhs, Number rhs) {
 	return lhs >= fixed<I, F>(rhs);
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<=(fixed<I, F> lhs, Number rhs) {
 	return lhs <= fixed<I, F>(rhs);
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator==(fixed<I, F> lhs, Number rhs) {
 	return lhs == fixed<I, F>(rhs);
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator!=(fixed<I, F> lhs, Number rhs) {
 	return lhs != fixed<I, F>(rhs);
@@ -642,26 +657,32 @@ template <size_t I, size_t F, class Number, class = typename std::enable_if<std:
 constexpr bool operator>(Number lhs, fixed<I, F> rhs) {
 	return fixed<I, F>(lhs) > rhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<(Number lhs, fixed<I, F> rhs) {
 	return fixed<I, F>(lhs) < rhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator>=(Number lhs, fixed<I, F> rhs) {
 	return fixed<I, F>(lhs) >= rhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<=(Number lhs, fixed<I, F> rhs) {
 	return fixed<I, F>(lhs) <= rhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator==(Number lhs, fixed<I, F> rhs) {
 	return fixed<I, F>(lhs) == rhs;
 }
+
 template <size_t I, size_t F, class Number, class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator!=(Number lhs, fixed<I, F> rhs) {
 	return fixed<I, F>(lhs) != rhs;
 }
+
 }
 
 #undef CONSTEXPR14

hash/include/cpp-utilities/md5.h

@@ -125,7 +125,8 @@ class md5 {
 			0x67452301,
 			0xefcdab89,
 			0x98badcfe,
-			0x10325476};
+			0x10325476,
+		};
 	};
 
 public:

hash/include/cpp-utilities/sha1.h

@@ -97,7 +97,8 @@ class sha1 {
 			0xefcdab89,
 			0x98badcfe,
 			0x10325476,
-			0xc3d2e1f0};
+			0xc3d2e1f0,
+		};
 	};
 
 public:

logger/include/cpp-utilities/logger.h

@@ -153,7 +153,7 @@ inline bool timedate() {
 }
 
 //------------------------------------------------------------------------------
-// Name: timedate
+// Name: fullpath
 //------------------------------------------------------------------------------
 inline bool fullpath() {
 	static const bool t = [] {

programs/byte_writer.cpp

@@ -1,15 +1,15 @@
 
-#include <iostream>
-#include <fstream>
 #include <cstdio>
+#include <fstream>
+#include <iostream>
 
 namespace {
-const int col = 16;
+constexpr int Columns = 16;
 }
 
 int main(int argc, char *argv[]) {
 
-	if(argc != 2) {
+	if (argc != 2) {
 		std::cerr << "usage: " << argv[0] << " <filename>\n";
 		return -1;
 	}
@@ -19,24 +19,23 @@ int main(int argc, char *argv[]) {
 	char ch;
 	size_t index = 0;
 
-	while(file.get(ch)) {
-		if(index == 0) {
+	while (file.get(ch)) {
+		if (index == 0) {
 			putchar('"');
 		}
 
 		printf("\\x%02x", static_cast<unsigned>(ch) & 0xff);
 
-		index = (index + 1) % col;
+		index = (index + 1) % Columns;
 
-		if(index == 0) {
+		if (index == 0) {
 			putchar('"');
 			putchar('\n');
 		}
 	}
 
-	if(index != 0) {
+	if (index != 0) {
 		putchar('"');
-		putchar('\n');	
+		putchar('\n');
 	}
-
 }

range/include/cpp-utilities/range.h

@@ -48,7 +48,7 @@ class const_iterator {
 		: value_(value) {
 	}
 
-	const_iterator(const const_iterator &) = default;
+	const_iterator(const const_iterator &)            = default;
 	const_iterator &operator=(const const_iterator &) = default;
 
 public:

uint128/include/cpp-utilities/uint128.h

@@ -71,7 +71,7 @@ static void divide(const T &numerator, const T &denominator, T &quotient, T &rem
 }
 }
 
-// convinience macro
+// convenience macro
 #define U128_C(s) uint128(#s)
 
 class uint128 : public boost::shiftable<uint128, boost::totally_ordered<uint128, boost::integer_arithmetic<uint128, boost::bitwise<uint128, boost::unit_steppable<uint128>>>>> {
@@ -324,10 +324,10 @@ class uint128 : public boost::shiftable<uint128, boost::totally_ordered<uint128,
 			hi = 0;
 			lo = 0;
 		} else {
-			const unsigned int halfsize = size / 2;
+			const unsigned int half_size = size / 2;
 
-			if (n >= halfsize) {
-				n -= halfsize;
+			if (n >= half_size) {
+				n -= half_size;
 				hi = lo;
 				lo = 0;
 			}
@@ -339,7 +339,7 @@ class uint128 : public boost::shiftable<uint128, boost::totally_ordered<uint128,
 				const base_type mask(~(base_type(-1) >> n));
 
 				// and add them to high half
-				hi |= (lo & mask) >> (halfsize - n);
+				hi |= (lo & mask) >> (half_size - n);
 
 				// and finally shift also low half
 				lo <<= n;
@@ -357,10 +357,10 @@ class uint128 : public boost::shiftable<uint128, boost::totally_ordered<uint128,
 			hi = 0;
 			lo = 0;
 		} else {
-			const unsigned int halfsize = size / 2;
+			const unsigned int half_size = size / 2;
 
-			if (n >= halfsize) {
-				n -= halfsize;
+			if (n >= half_size) {
+				n -= half_size;
 				lo = hi;
 				hi = 0;
 			}
@@ -373,7 +373,7 @@ class uint128 : public boost::shiftable<uint128, boost::totally_ordered<uint128,
 				const base_type mask(~(base_type(-1) << n));
 
 				// and add them to low qword
-				lo |= (hi & mask) << (halfsize - n);
+				lo |= (hi & mask) << (half_size - n);
 
 				// and finally shift also high half
 				hi >>= n;

uuid/include/cpp-utilities/uuid.h

@@ -34,8 +34,8 @@
 
 class uuid {
 public:
-	uuid()             = default;
-	uuid(const uuid &) = default;
+	uuid()                        = default;
+	uuid(const uuid &)            = default;
 	uuid &operator=(const uuid &) = default;
 
 public: