Superseded by MaximInterface.

Diff: Utilities/array.h

Revision:

139:f0e0a7976846

Parent:

86:2ce08ca58b9e

--- a/Utilities/array.h	Fri Dec 02 19:21:55 2016 +0000
+++ b/Utilities/array.h	Tue Dec 13 13:31:30 2016 -0800
@@ -35,6 +35,8 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include <iterator>
+#include <algorithm>
 #include <cstring>
 
 namespace OneWire
@@ -44,58 +46,55 @@
     class array
     {
     public:
-        /// Number of elements contained in the array.
-        static const size_t length = N;
-
-        /// Built-in array representation.
-        typedef T Buffer[N];
-
-    private:
-        Buffer m_buffer;
-
-    public:
-        const array<T, N> & operator=(const array<T, N> & rhs)
-        {
-            if (this != &rhs)
-            {
-                std::memcpy(this->m_buffer, rhs.m_buffer, N * sizeof(T));
-            }
-            return rhs;
-        }
-
-        bool operator==(const array<T, N> & rhs) const
-        {
-            return (std::memcmp(this->m_buffer, rhs.m_buffer, N * sizeof(T)) == 0);
-        }
-
-        bool operator!=(const array<T, N> & rhs) const
-        {
-            return !operator==(rhs);
-        }
-
-        /// Conversion to array reference.
-        operator Buffer &()
-        {
-            return m_buffer;
-        }
-
-        /// Conversion to const array reference.
-        operator const Buffer &() const
-        {
-            return m_buffer;
-        }
-
-        array<T, N>() { }
-
-        array<T, N>(const array<T, N> & copy)
-        {
-            operator=(copy);
-        }
-
-        array<T, N>(const Buffer & buffer)
-        {
-            std::memcpy(m_buffer, buffer, N * sizeof(T));
-        }
+        typedef T value_type;
+        typedef size_t size_type;
+        typedef ptrdiff_t difference_type;
+        typedef value_type & reference;
+        typedef const value_type & const_reference;
+        typedef value_type * pointer;
+        typedef const value_type * const_pointer;
+        typedef pointer iterator;
+        typedef const_pointer const_iterator;
+        typedef std::reverse_iterator<iterator> reverse_iterator;
+        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+        
+        // Element access
+        reference operator[](size_t pos) { return _buffer[pos]; }
+        const_reference operator[](size_t pos) const { return _buffer[pos]; }
+        reference front() { return const_cast<reference>(static_cast<const array<T, N> &>(*this).front()); }
+        const_reference front() const { return _buffer[0]; }
+        reference back() { return const_cast<reference>(static_cast<const array<T, N> &>(*this).back()); }
+        const_reference back() const { return _buffer[N - 1]; }
+        T * data() { return const_cast<T *>(static_cast<const array<T, N> &>(*this).data()); }
+        const T * data() const { return _buffer; }
+        
+        // Iterators
+        iterator begin() { return const_cast<iterator>(static_cast<const array<T, N> &>(*this).begin()); }
+        const_iterator begin() const { return cbegin(); }
+        const_iterator cbegin() const { return &front(); }
+        iterator end() { return const_cast<iterator>(static_cast<const array<T, N> &>(*this).end()); }
+        const_iterator end() const { return cend(); }
+        const_iterator cend() const { return &_buffer[N]; }
+        reverse_iterator rbegin() { return reverse_iterator(&back()); }
+        const_reverse_iterator rbegin() const { return crbegin(); }
+        const_reverse_iterator crbegin() const { return const_reverse_iterator(&back()); }
+        reverse_iterator rend() { return reverse_iterator(--begin()); }
+        const_reverse_iterator rend() const { return crend(); }
+        const_reverse_iterator crend() const { return const_reverse_iterator(--begin()); }
+        
+        // Capacity
+        static bool empty() { return size() == 0; }
+        static size_type size() { return N; }
+        static size_type max_size() { return size(); }
+        static const size_type csize = N; ///< Alternative to size() when a constant expression is required.
+        
+        // Operations
+        void fill(const T & value) { std::fill(begin(), end(), value); }
+        
+        bool operator==(const array<T, N> & rhs) const { return (std::memcmp(this->_buffer, rhs._buffer, N * sizeof(T)) == 0); }
+        bool operator!=(const array<T, N> & rhs) const { return !operator==(rhs); }
+        
+        T _buffer[N];
     };
 }