Array.hpp

Go to the documentation of this file.

// ======================================================================
// \file   Array.hpp
// \author bocchino
// \brief  A statically-sized, bounds checked array
// ======================================================================

#ifndef Fw_Array_HPP
#define Fw_Array_HPP

#include <initializer_list>

#include "Fw/DataStructures/ExternalArray.hpp"
#include "Fw/FPrimeBasicTypes.hpp"
#include "Fw/Types/Assert.hpp"

namespace Fw {

template <typename T, FwSizeType S>
class Array final {
    // ----------------------------------------------------------------------
    // Static assertions
    // ----------------------------------------------------------------------

    static_assert(std::is_default_constructible<T>::value, "T must be default constructible");
    static_assert(S > 0, "array size must be greater than zero");

  public:
    // ----------------------------------------------------------------------
    // Types
    // ----------------------------------------------------------------------

    using Elements = T[S];

  public:
    // ----------------------------------------------------------------------
    // Public constructors and destructors
    // ----------------------------------------------------------------------

    Array() = default;

    Array(const std::initializer_list<T>& il  
    ) {
        *this = il;
    }

    Array(const Elements& elements  
    ) {
        *this = elements;
    }

    explicit Array(const T& element  
    ) {
        *this = element;
    }

    Array(const Array<T, S>& a  
    ) {
        *this = a;
    }

    ~Array() = default;

  public:
    // ----------------------------------------------------------------------
    // Public member functions
    // ----------------------------------------------------------------------

    T& operator[](FwSizeType i  
    ) {
        FW_ASSERT(i < S, static_cast<FwAssertArgType>(i));
        return this->m_elements[i];
    }

    const T& operator[](FwSizeType i  
    ) const {
        FW_ASSERT(i < S, static_cast<FwAssertArgType>(i));
        return this->m_elements[i];
    }

    Array<T, S>& operator=(const std::initializer_list<T>& il  
    ) {
        // Since we are required to use C++11, this has to be a runtime check
        // In C++14, it can be a static check
        FW_ASSERT(il.size() == S, static_cast<FwAssertArgType>(il.size()), static_cast<FwAssertArgType>(S));
        FwSizeType i = 0;
        for (const auto& e : il) {
            FW_ASSERT(i < S, static_cast<FwAssertArgType>(i), static_cast<FwAssertArgType>(S));
            this->m_elements[i] = e;
            i++;
        }
        return *this;
    }

    Array<T, S>& operator=(const Elements& elements  
    ) {
        for (FwSizeType i = 0; i < S; i++) {
            this->m_elements[i] = elements[i];
        }
        return *this;
    }

    Array<T, S>& operator=(const T& element  
    ) {
        for (FwSizeType i = 0; i < S; i++) {
            this->m_elements[i] = element;
        }
        return *this;
    }

    Array<T, S>& operator=(const Array<T, S>& a) {
        if (&a != this) {
            for (FwSizeType i = 0; i < S; i++) {
                this->m_elements[i] = a.m_elements[i];
            }
        }
        return *this;
    }

    Elements& getElements() { return this->m_elements; }

    const Elements& getElements() const { return this->m_elements; }

    // \return The ExternalArray
    ExternalArray<T> asExternalArray() { return ExternalArray<T>(this->m_elements, S); }

  private:
    // ----------------------------------------------------------------------
    // Private member variables
    // ----------------------------------------------------------------------

    Elements m_elements = {};
};

}  // namespace Fw

#endif