array.hpp

/*********************************************************************
 *
 * Linear Arrangement Library - A library that implements a collection
 * algorithms for linear arrangments of graphs.
 *
 * Copyright (C) 2019 - 2024
 *
 * This file is part of Linear Arrangement Library. The full code is available
 * at:
 *      https://github.com/LAL-project/linear-arrangement-library.git
 *
 * Linear Arrangement Library is free software: you can redistribute it
 * and/or modify it under the terms of the GNU Affero General Public License
 * as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * Linear Arrangement Library 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Linear Arrangement Library.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Contact:
 *
 *     Lluís Alemany Puig (lluis.alemany.puig@upc.edu)
 *         LQMC (Quantitative, Mathematical, and Computational Linguisitcs)
 *         CQL (Complexity and Quantitative Linguistics Lab)
 *         Jordi Girona St 1-3, Campus Nord UPC, 08034 Barcelona.   CATALONIA, SPAIN
 *         Webpage: https://cqllab.upc.edu/people/lalemany/
 *
 *     Ramon Ferrer i Cancho (rferrericancho@cs.upc.edu)
 *         LQMC (Quantitative, Mathematical, and Computational Linguisitcs)
 *         CQL (Complexity and Quantitative Linguistics Lab)
 *         Office 220, Omega building
 *         Jordi Girona St 1-3, Campus Nord UPC, 08034 Barcelona.   CATALONIA, SPAIN
 *         Webpage: https://cqllab.upc.edu/people/rferrericancho/
 *
 ********************************************************************/
 
#pragma once
 
// C++ includes
#if defined DEBUG
#include <cassert>
#endif
#include <algorithm>
 
namespace lal {
namespace detail {
 
template <typename T>
struct array {
public:
    array() noexcept = default;
 
    array(std::initializer_list<T> l) noexcept : m_size(l.size()) {
        // (un?)fortunately, this will call the constructor of T
        // for every element in m_data.
        alloc_data();
        // array reference
        const T * const list_data = std::data(l);
        for (std::size_t i = 0; i < l.size(); ++i) {
            // the data has to be be copied, it cannot be moved
            // unless 'list_data' is const_cast<T *>-ed.
            m_data[i] = list_data[i];
        }
    }
 
    array(const std::size_t n) noexcept : m_size(n) {
        alloc_data();
    }
    array(const std::size_t n, const T& v) noexcept : array(n) {
        fill(v);
    }
    array(const array& d) noexcept : array(d.m_size) {
        if (m_size > 0) {
            std::copy(d.begin(), d.end(), begin());
        }
    }
    array& operator= (const array& d) noexcept {
        if (m_size != d.m_size) {
            delete[] m_data;
            m_size = d.m_size;
            alloc_data();
        }
        if (m_size > 0) {
            std::copy(d.begin(), d.end(), begin());
        }
        return *this;
    }
 
    array(array&& d) noexcept {
        // steal data
        m_data = d.m_data;
        m_size = d.m_size;
        // invalidate data
        d.m_data = nullptr;
        d.m_size = 0;
    }
    array& operator= (array&& d) noexcept {
        // free yourself
        delete[] m_data;
        // steal from others
        m_data = d.m_data;
        m_size = d.m_size;
        // invalidate data
        d.m_data = nullptr;
        d.m_size = 0;
        return *this;
    }
 
    /*
    template <template <typename... Args> class container, typename... Types>
    array(const container<Types...>& v) noexcept : array(v.size()) {
        // assert first type in Types... is 'T'
        static_assert(std::is_same_v<T, std::tuple_element_t<0, std::tuple<Types...>>>);
 
        std::copy(v.begin(), v.end(), begin());
    }
 
    template <template <typename... Args> class container, typename... Types>
    array& operator= (const container<Types...>& v) noexcept {
        // assert first type in Types... is 'T'
        static_assert(std::is_same_v<T, std::tuple_element_t<0, std::tuple<Types...>>>);
 
        resize(v.size());
        std::copy(v.begin(), v.end(), begin());
        return *this;
    }
    */
 
    ~array() noexcept {
        clear();
    }
 
    [[nodiscard]] bool operator== (const array& d) const noexcept {
        if (size() != d.size()) { return size() < d.size(); }
 
        for (std::size_t i = 0; i < size(); ++i) {
            if (m_data[i] != d.m_data[i]) {
                return false;
            }
        }
        return true;
    }
 
    void clear() noexcept {
        delete[] m_data;
        m_size = 0;
        // this is for those who like calling the destructor...
        m_data = nullptr;
    }
 
    void resize(const std::size_t new_size) noexcept {
        if (new_size != m_size or m_data == nullptr) {
            delete[] m_data;
            m_size = new_size;
            alloc_data();
        }
    }
 
    void resize(const std::size_t new_size, const T& v) noexcept {
        resize(new_size);
        if (m_size > 0) {
            fill(v);
        }
    }
 
    [[nodiscard]] std::size_t size() const noexcept { return m_size; }
 
    [[nodiscard]] T& operator[] (const std::size_t i) noexcept {
#if defined DEBUG
        assert(i < size());
#endif
        return m_data[i];
    }
    [[nodiscard]] const T& operator[] (const std::size_t i) const noexcept {
#if defined DEBUG
        assert(i < size());
#endif
        return m_data[i];
    }
 
    [[nodiscard]] T& first() noexcept {
#if defined DEBUG
        assert(m_size > 0);
#endif
        return *m_data;
    }
    [[nodiscard]] const T& first() const noexcept {
#if defined DEBUG
        assert(m_size > 0);
#endif
        return *m_data;
    }
    [[nodiscard]] T& back() noexcept {
#if defined DEBUG
        assert(m_size > 0);
#endif
        return *(m_data + m_size - 1);
    }
    [[nodiscard]] const T& back() const noexcept {
#if defined DEBUG
        assert(m_size > 0);
#endif
        return *(m_data + m_size - 1);
    }
 
    void fill(const T& v) noexcept {
        std::fill(begin(), end(), v);
    }
 
    [[nodiscard]] T *at(const std::size_t i) noexcept {
#if defined DEBUG
        assert(i < m_size);
#endif
        return &m_data[i];
    }
    [[nodiscard]] T const *at(const std::size_t i) const noexcept {
#if defined DEBUG
        assert(i < m_size);
#endif
        return &m_data[i];
    }
 
    [[nodiscard]] T *begin() noexcept { return m_data; }
    [[nodiscard]] T *end() noexcept { return m_data + m_size; }
 
    [[nodiscard]] T const *begin() const noexcept { return m_data; }
    [[nodiscard]] T const *end() const noexcept { return m_data + m_size; }
 
private:
    void alloc_data() noexcept {
        m_data = m_size == 0 ? nullptr : new T[m_size];
    }
 
protected:
    T *m_data = nullptr;
    std::size_t m_size = 0;
};
 
} // -- namespace detail
} // -- namespace lal