From e130eb6cf04c49de36646b7a3e1caad8e67d2936 Mon Sep 17 00:00:00 2001
From: q66 <daniel@octaforge.org>
Date: Wed, 3 Jun 2015 23:10:10 +0100
Subject: [PATCH] deuglify array.h

---
 octa/array.h | 82 +++++++++++++++++++++++++++-------------------------
 1 file changed, 42 insertions(+), 40 deletions(-)

diff --git a/octa/array.h b/octa/array.h
index 1c734ee..b57ed12 100644
--- a/octa/array.h
+++ b/octa/array.h
@@ -13,56 +13,58 @@
 #include "octa/string.h"
 
 namespace octa {
-    template<typename _T, size_t _N>
-    struct Array {
-        typedef size_t                  Size;
-        typedef ptrdiff_t               Difference;
-        typedef       _T                Value;
-        typedef       _T               &Reference;
-        typedef const _T               &ConstReference;
-        typedef       _T               *Pointer;
-        typedef const _T               *ConstPointer;
-        typedef PointerRange<      _T>  Range;
-        typedef PointerRange<const _T>  ConstRange;
 
-        _T &operator[](size_t __i) { return __buf[__i]; }
-        const _T &operator[](size_t __i) const { return __buf[__i]; }
+template<typename _T, size_t _N>
+struct Array {
+    typedef size_t                  Size;
+    typedef ptrdiff_t               Difference;
+    typedef       _T                Value;
+    typedef       _T               &Reference;
+    typedef const _T               &ConstReference;
+    typedef       _T               *Pointer;
+    typedef const _T               *ConstPointer;
+    typedef PointerRange<      _T>  Range;
+    typedef PointerRange<const _T>  ConstRange;
 
-        _T &at(size_t __i) { return __buf[__i]; }
-        const _T &at(size_t __i) const { return __buf[__i]; }
+    _T &operator[](size_t i) { return p_buf[i]; }
+    const _T &operator[](size_t i) const { return p_buf[i]; }
 
-        _T &front() { return __buf[0]; }
-        const _T &front() const { return __buf[0]; }
+    _T &at(size_t i) { return p_buf[i]; }
+    const _T &at(size_t i) const { return p_buf[i]; }
 
-        _T &back() { return __buf[(_N > 0) ? (_N - 1) : 0]; }
-        const _T &back() const { return __buf[(_N > 0) ? (_N - 1) : 0]; }
+    _T &front() { return p_buf[0]; }
+    const _T &front() const { return p_buf[0]; }
 
-        size_t size() const { return _N; }
+    _T &back() { return p_buf[(_N > 0) ? (_N - 1) : 0]; }
+    const _T &back() const { return p_buf[(_N > 0) ? (_N - 1) : 0]; }
 
-        bool empty() const { return _N == 0; }
+    size_t size() const { return _N; }
 
-        bool in_range(size_t __idx) { return __idx < _N; }
-        bool in_range(int __idx) { return __idx >= 0 && size_t(__idx) < _N; }
-        bool in_range(const _T *__ptr) {
-            return __ptr >= &__buf[0] && __ptr < &__buf[_N];
-        }
+    bool empty() const { return _N == 0; }
 
-        _T *data() { return __buf; }
-        const _T *data() const { return __buf; }
+    bool in_range(size_t idx) { return idx < _N; }
+    bool in_range(int idx) { return idx >= 0 && size_t(idx) < _N; }
+    bool in_range(const _T *ptr) {
+        return ptr >= &p_buf[0] && ptr < &p_buf[_N];
+    }
 
-        Range each() {
-            return octa::PointerRange<_T>(__buf, __buf + _N);
-        }
-        ConstRange each() const {
-            return octa::PointerRange<const _T>(__buf, __buf + _N);
-        }
+    _T *data() { return p_buf; }
+    const _T *data() const { return p_buf; }
 
-        void swap(Array &__v) {
-            octa::swap_ranges(each(), __v.each());
-        }
+    Range each() {
+        return octa::PointerRange<_T>(p_buf, p_buf + _N);
+    }
+    ConstRange each() const {
+        return octa::PointerRange<const _T>(p_buf, p_buf + _N);
+    }
 
-        _T __buf[(_N > 0) ? _N : 1];
-    };
-}
+    void swap(Array &v) {
+        octa::swap_ranges(each(), v.each());
+    }
+
+    _T p_buf[(_N > 0) ? _N : 1];
+};
+
+} /* namespace octa */
 
 #endif
\ No newline at end of file