array.h

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
#ifndef ARRAY_HH
#define ARRAY_HH
 
#include <stdint.h>
#include "initializer_list.h"
 
namespace containers
{
    template<typename T_, uint8_t N_>
    class array
    {
    public:
        using T = T_;
        static constexpr uint8_t N = N_;
        using TREF = T_&;
        using CTREF = const T_&;
        using TPTR = T_*;
        using CTPTR = const T_*;
 
        array() = default;
 
        array(T buffer[N])
        {
            T* dst = buffer_;
            const T* src = buffer;
            for (uint8_t i = 0; i < N; ++i)
                *dst++ = *src++;
        }
 
        array(std::initializer_list<T> list)
        {
            T* dst = buffer_;
            auto src = list.begin();
            for (uint8_t i = 0; i < N; ++i)
            {
                if (src != list.end())
                    *dst++ = *src++;
                else
                    *dst++ = T{};
            }
        }
 
        array(const array<T, N>& that)
        {
            T* dst = buffer_;
            const T* src = that.buffer_;
            for (uint8_t i = 0; i < N; ++i)
                *dst++ = *src++;
        }
 
        array<T, N>& operator=(const T buffer[N])
        {
            T* dst = buffer_;
            const T* src = buffer;
            for (uint8_t i = 0; i < N; ++i)
                *dst++ = *src++;
            return *this;
        }
 
        array<T, N>& operator=(std::initializer_list<T> list)
        {
            T* dst = buffer_;
            auto src = list.begin();
            for (uint8_t i = 0; i < N; ++i)
            {
                if (src != list.end())
                    *dst++ = *src++;
                else
                    *dst++ = T{};
            }
        }
 
        array& operator=(const array& that)
        {
            if (this == &that) return *this;
            T* dst = buffer_;
            const T* src = that.buffer_;
            for (uint8_t i = 0; i < N; ++i)
                *dst++ = *src++;
            return *this;
        }
 
        CTPTR data() const
        {
            return buffer_;
        }
 
        TPTR data()
        {
            return buffer_;
        }
 
        constexpr uint8_t size() const
        {
            return N;
        }
 
        CTREF operator[](uint8_t index) const
        {
            return buffer_[index];
        }
 
        TREF operator[](uint8_t index)
        {
            return buffer_[index];
        }
 
        TPTR begin()
        {
            return buffer_;
        }
 
        TPTR end()
        {
            return buffer_ + N;
        }
 
        CTPTR begin() const
        {
            return buffer_;
        }
 
        CTPTR end() const
        {
            return buffer_ + N;
        }
 
        template<uint8_t NN>
        void set(uint8_t index, const T (&buffer)[NN])
        {
            if (index >= N) return;
            const uint8_t nn = ((N - index) < NN) ? (N - index) : NN;
            T* dst = &buffer_[index];
            const T* src = buffer;
            for (uint8_t i = 0; i < nn; ++i)
                *dst++ = *src++;
        }
 
        template<uint8_t NN>
        void set(uint8_t index, const array<T, NN>& buffer)
        {
            if (index >= N) return;
            const uint8_t nn = ((N - index) < NN) ? (N - index) : NN;
            T* dst = &buffer_[index];
            const T* src = buffer.data();
            for (uint8_t i = 0; i < nn; ++i)
                *dst++ = *src++;
        }
 
    private:
        T buffer_[N] = {};
    };
}
#endif /* ARRAY_HH */