PstArray.h

Go to the documentation of this file.

// Copyright PS-Tech B.V. All Rights Reserved.
 
#pragma once
 
#include "TrackerExceptions.h"
 
#include <cstddef>
#include <cassert>
 
namespace PSTech
{
namespace Utils
{
    template<typename T, size_t Size>
    class PstArray
    {
    public:
        typedef T value_type;
        typedef size_t size_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T* iterator;
        typedef const T* const_iterator;
 
        constexpr size_type size() const
        {
            return Size;
        }
        
        constexpr bool empty() const
        {
            return Size == 0;
        }
 
        const_pointer data() const
        {
            return _array;
        }
 
        pointer data()
        {
            return _array;
        }
 
        const_reference at(size_type index) const
        {
            check_bounds(index);
            return _array[index];
        }
 
        reference at(size_type index)
        {
            check_bounds(index);
            return _array[index];
        }
 
        const_reference front() const
        {
            assert(Size > 0);
            return _array[0];
        }
 
        reference front()
        {
            assert(Size > 0);
            return _array[0];
        }
 
        const_reference back() const
        {
            assert(Size > 0);
            return _array[Size - 1];
        }
 
        reference back()
        {
            assert(Size > 0);
            return _array[Size - 1];
        }
 
        const_iterator cbegin() const
        {
            return _array;
        }
 
        const_iterator begin() const
        {
            return _array;
        }
 
        iterator begin()
        {
            return _array;
        }
 
        const_iterator cend() const
        {
            return _array + Size;
        }
 
        const_iterator end() const
        {
            return _array + Size;
        }
 
        iterator end()
        {
            return _array + Size;
        }
 
        const_reference operator [] (size_type index) const
        {
            assert(index < Size);
            return _array[index];
        }
 
        reference operator [] (size_type index)
        {
            assert(index < Size);
            return _array[index];
        }
 
        bool operator==(const PstArray<T, Size>& array) const
        {
            for (size_t index = 0; index < Size; ++index)
            {
                if (_array[index] != array[index])
                {
                    return false;
                }
            }
            return true;
        }
 
        bool operator!=(const PstArray<T, Size>& array) const
        {            
            return !(*this == array);
        }
        
        value_type _array[Size];
 
    private:
        void check_bounds(size_type index)
        {
            if (index >= Size)
            {
                throw OutOfRangeException(("Requested index out of range: " + std::to_string(index) + " >= " + std::to_string(Size)).c_str());
            }
        }
    };
}
}