array.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
 
#ifndef FENNEC_CONTAINERS_ARRAY_H
#define FENNEC_CONTAINERS_ARRAY_H
 
#include <fennec/lang/types.h>
#include <fennec/lang/assert.h>
#include <fennec/lang/metasequences.h>
 
namespace fennec
{
 
template<typename ValueT, size_t ElemV>
struct array {
 
// Definitions =========================================================================================================
public:
    using value_t = ValueT; 
 
// Public Members ======================================================================================================
 
 
    value_t data[ElemV];
 
 
 
 
// Properties ==========================================================================================================
 
 
    [[nodiscard]] constexpr size_t size() const { return ElemV; }
 
    [[nodiscard]] constexpr bool_t empty() const { return ElemV == 0; }
 
 
 
 
// Access ==============================================================================================================
 
 
    constexpr value_t& operator[](size_t i) {
        assertd(i < ElemV, "Array Out of Bounds");
        return data[i];
    }
 
    constexpr const value_t& operator[](size_t i) const {
        assertd(i < ElemV, "Array Out of Bounds");
        return data[i];
    }
 
    constexpr value_t& front() {
        return data[0];
    }
 
    constexpr const value_t& front() const {
        return data[0];
    }
 
    constexpr value_t& back() {
        return data[ElemV - 1];
    }
 
    constexpr const value_t& back() const {
        return data[ElemV - 1];
    }
 
 
 
 
// Comparison ==========================================================================================================
 
 
    friend constexpr bool_t operator==(const array& lhs, const array& rhs) {
        return array::_compare(lhs, rhs, make_index_metasequence<ElemV>{});
    }
 
    friend constexpr bool_t operator!=(const array& lhs, const array& rhs) {
        return not array::_compare(lhs, rhs, make_index_metasequence<ElemV>{});
    }
 
 
 
// Iteration ===========================================================================================================
 
 
    constexpr value_t* begin() {
        return data;
    }
 
    constexpr value_t* end() {
        return data + ElemV;
    }
 
 
 
    constexpr const value_t* begin() const {
        return data;
    }
 
    constexpr const value_t* end() const {
        return data + ElemV;
    }
 
 
private:
    template<size_t...i>
    static bool _compare(const array& lhs, const array& rhs, index_metasequence<i...>) {
        return ((lhs[i] == rhs[i]) && ...);
    }
};
 
}
 
#endif // FENNEC_CONTAINERS_ARRAY_H