hxconstexpr_list.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#include "hxptr.hpp"
#include "hxutility.h"
 
HX_NS_BEGIN_

class hxconstexpr_list_node {
public:
    hxconstexpr hxconstexpr_list_node(void) : m_list_prev_(hxnull), m_list_next_(hxnull) { }

    hxconstexpr hxconstexpr_list_node(const hxconstexpr_list_node&) : hxconstexpr_list_node() { }

    hxconstexpr hxconstexpr_list_node& operator=(const hxconstexpr_list_node& other_) {
        hxassertmsg(this != &other_, "self_assignment"); (void)other_;
        return *this;
    }
 
private:
    template<typename, typename> friend class hxconstexpr_list;
    hxconstexpr_list_node* m_list_prev_;
    hxconstexpr_list_node* m_list_next_;
};

template<typename T_, typename deleter_t_=hxdefault_delete>
class hxconstexpr_list : private deleter_t_ {
public:
    using node_t = T_;

    class const_iterator {
    public:
        // GCOVR_EXCL_START
        hxconstexpr const_iterator(void) : m_current_node_(hxnull)
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_DEBUG
            , m_sentinel_(hxnull)
#endif
        { }
        // GCOVR_EXCL_STOP
        hxconstexpr const_iterator& operator++(void);
        hxconstexpr const_iterator operator++(int);
        hxconstexpr const_iterator& operator--(void);
        hxconstexpr const_iterator operator--(int);
        hxconstexpr bool operator==(const const_iterator& x_) const;
#if HX_CPLUSPLUS < 202002L // C++20 defaults != from ==.
        hxconstexpr bool operator!=(const const_iterator& x_) const { return !(*this == x_); }
#endif
        hxconstexpr const T_& operator*(void) const {
            hxassertmsg(this->m_current_node_ != hxnull
                && this->m_current_node_ != this->m_sentinel_, "invalid_iterator");
            return *static_cast<const T_*>(m_current_node_);
        }

        hxconstexpr const T_* operator->(void) const {
            hxassertmsg(this->m_current_node_ != hxnull
                && this->m_current_node_ != this->m_sentinel_, "invalid_iterator");
            return static_cast<const T_*>(m_current_node_);
        }
    protected:
        template<typename, typename> friend class hxconstexpr_list;
        hxconstexpr const_iterator(hxconstexpr_list_node* current_, const hxconstexpr_list_node* sentinel_)
            : m_current_node_(current_)
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_DEBUG
            , m_sentinel_(sentinel_)
#endif
        { (void)sentinel_; }
        hxconstexpr_list_node* m_current_node_;
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_DEBUG
        const hxconstexpr_list_node* m_sentinel_;
#endif
    };

    class iterator : public const_iterator {
    public:
        // GCOVR_EXCL_START
        hxconstexpr iterator(void) { }
        // GCOVR_EXCL_STOP
        hxconstexpr iterator& operator++(void) { const_iterator::operator++(); return *this; }
        hxconstexpr iterator operator++(int);
        hxconstexpr iterator& operator--(void) { const_iterator::operator--(); return *this; }
        hxconstexpr iterator operator--(int);
        hxconstexpr T_& operator*(void) const {
            hxassertmsg(this->m_current_node_ != hxnull
                && this->m_current_node_ != this->m_sentinel_, "invalid_iterator");
            return *static_cast<T_*>(this->m_current_node_);
        }

        hxconstexpr T_* operator->(void) const {
            hxassertmsg(this->m_current_node_ != hxnull
                && this->m_current_node_ != this->m_sentinel_, "invalid_iterator");
            return static_cast<T_*>(this->m_current_node_);
        }
    private:
        template<typename, typename> friend class hxconstexpr_list;
        hxconstexpr iterator(hxconstexpr_list_node* current_, const hxconstexpr_list_node* sentinel_)
            : const_iterator(current_, sentinel_) { }
    };

    hxconstexpr explicit hxconstexpr_list(deleter_t_ deleter_=deleter_t_());

    hxconstexpr ~hxconstexpr_list(void) { this->clear(this->deleter()); }

    hxattr_nodiscard hxconstexpr T_& back(void);

    hxattr_nodiscard hxconstexpr const T_& back(void) const;

    hxconstexpr iterator begin(void) { return iterator(m_sentinel_.m_list_next_, &m_sentinel_); }

    hxconstexpr const_iterator begin(void) const;

    hxconstexpr const_iterator cbegin(void) const { return this->begin(); }

    hxconstexpr const_iterator cend(void) const { return this->end(); }

    template<typename deleter_u_>
    hxconstexpr void clear(deleter_u_&& deleter_) noexcept;

    hxinline hxconstexpr void clear(void) { this->clear(this->deleter()); }

    hxattr_nodiscard hxconstexpr bool empty(void) const;

    hxconstexpr iterator end(void) { return iterator(&m_sentinel_, &m_sentinel_); }

    hxconstexpr const_iterator end(void) const;

    template<typename deleter_u_>
    hxconstexpr void erase(const_iterator pos_, deleter_u_&& deleter_) noexcept;

    hxconstexpr void erase(const_iterator pos_) noexcept;

    hxconstexpr hxptr<T_, deleter_t_> extract(const_iterator pos_);

    template<typename callable_t_>
    hxattr_nodiscard hxconstexpr const_iterator find_if(callable_t_&& callable_) const;

    template<typename callable_t_>
    hxattr_nodiscard hxconstexpr iterator find_if(callable_t_&& callable_);

    template<typename callable_t_>
    hxconstexpr void for_each(callable_t_&& callable_) const;

    template<typename callable_t_>
    hxconstexpr void for_each(callable_t_&& callable_);

    hxattr_nodiscard hxconstexpr const deleter_t_& deleter(void) const;

    hxattr_nodiscard hxconstexpr deleter_t_& deleter(void);

    hxattr_nodiscard hxconstexpr T_& front(void);

    hxattr_nodiscard hxconstexpr const T_& front(void) const;

    template<typename deleter_u_>
    hxconstexpr iterator insert_after(const_iterator pos_, hxptr<T_, deleter_u_>&& ptr_);

    hxconstexpr iterator insert_after(const_iterator pos_, T_* ptr_);

    template<typename deleter_u_>
    hxconstexpr iterator insert(const_iterator pos_, hxptr<T_, deleter_u_>&& ptr_);

    hxconstexpr iterator insert(const_iterator pos_, T_* ptr_);

    hxconstexpr hxptr<T_, deleter_t_> pop_back(void);

    hxconstexpr hxptr<T_, deleter_t_> pop_front(void);

    template<typename deleter_u_>
    hxconstexpr iterator push_back(hxptr<T_, deleter_u_>&& ptr_);

    hxconstexpr iterator push_back(T_* ptr_);

    template<typename deleter_u_>
    hxconstexpr iterator push_front(hxptr<T_, deleter_u_>&& ptr_);

    hxconstexpr iterator push_front(T_* ptr_);

    hxconstexpr void release_all(void);

    template<typename callable_t_, typename deleter_u_>
    hxconstexpr hxsize_t remove_if(callable_t_&& callable_, deleter_u_&& deleter_) noexcept;

    template<typename callable_t_>
    hxconstexpr hxsize_t remove_if(callable_t_&& callable_) noexcept;

    hxconstexpr void reverse(void);

    hxattr_nodiscard hxconstexpr hxsize_t size(void) const { return m_size_; }

    hxconstexpr void splice(const_iterator pos_, hxconstexpr_list& other_);
 
private:
    hxconstexpr_list(const hxconstexpr_list&) = delete;
    hxconstexpr_list(hxconstexpr_list&&) = delete;
    hxconstexpr_list& operator=(const hxconstexpr_list&) = delete;
    hxconstexpr_list& operator=(hxconstexpr_list&&) = delete;
 
    hxconstexpr void insert_(hxconstexpr_list_node* prev_, hxconstexpr_list_node* next_,
        hxconstexpr_list_node* ptr_);
    hxconstexpr void extract_(hxconstexpr_list_node* ptr_);
 
    hxsize_t m_size_;
    hxconstexpr_list_node m_sentinel_;
};
 
#include "detail/hxconstexpr_list.inl"
HX_NS_END_