606 lines
21 KiB
C++
606 lines
21 KiB
C++
//
|
|
// Created by Patrick Maschek on 19.01.2024.
|
|
//
|
|
|
|
#ifndef UDIFF_CONST_LIST_H_
|
|
#define UDIFF_CONST_LIST_H_
|
|
|
|
#include <concepts>
|
|
#include <initializer_list>
|
|
#include <iterator>
|
|
#include "allocator.h"
|
|
|
|
namespace cc {
|
|
|
|
class const_list_node;
|
|
|
|
template<typename N>
|
|
requires std::derived_from<N, const_list_node>
|
|
class _const_list_iterator_base {
|
|
protected:
|
|
N *_curr;
|
|
|
|
public:
|
|
constexpr _const_list_iterator_base() noexcept : _curr() {}
|
|
constexpr explicit _const_list_iterator_base(N *curr) noexcept : _curr(curr) {}
|
|
constexpr _const_list_iterator_base(const _const_list_iterator_base& other) noexcept : _curr(other._curr) {}
|
|
|
|
constexpr virtual const N& operator*() const { return *_curr; }
|
|
constexpr virtual const N* operator->() const noexcept { return _curr; }
|
|
|
|
constexpr virtual _const_list_iterator_base &operator++() noexcept = 0;
|
|
constexpr virtual _const_list_iterator_base &operator--() noexcept = 0;
|
|
constexpr virtual _const_list_iterator_base operator++(int) & noexcept = 0;
|
|
constexpr virtual _const_list_iterator_base operator--(int) & noexcept = 0;
|
|
|
|
constexpr bool operator==(const _const_list_iterator_base &other) { return _curr == other._curr; }
|
|
};
|
|
|
|
template<typename N>
|
|
class _const_list_iterator : public _const_list_iterator_base<N> {
|
|
using _Base = _const_list_iterator_base<N>;
|
|
public:
|
|
constexpr _const_list_iterator() noexcept : _Base() {}
|
|
constexpr explicit _const_list_iterator(N *curr) noexcept : _Base(curr) {}
|
|
constexpr _const_list_iterator(const _Base& other) noexcept : _Base(other) {}
|
|
|
|
constexpr N& operator*() const override { return *_Base::_curr; }
|
|
constexpr N* operator->() const override { return _Base::_curr; }
|
|
|
|
constexpr _const_list_iterator &operator++() noexcept override { _Base::_curr == _Base::_curr->_next; return *this; }
|
|
constexpr _const_list_iterator &operator--() noexcept override { _Base::_curr == _Base::_curr->_prev; return *this; }
|
|
constexpr _const_list_iterator operator++(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_next; return tmp; }
|
|
constexpr _const_list_iterator operator--(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_prev; return tmp; }
|
|
};
|
|
|
|
template<typename N>
|
|
class _const_const_list_iterator : public _const_list_iterator_base<N> {
|
|
using _Base = _const_list_iterator_base<N>;
|
|
public:
|
|
constexpr _const_const_list_iterator() : _Base() {}
|
|
constexpr explicit _const_const_list_iterator(N *curr) : _Base(curr) {}
|
|
constexpr _const_const_list_iterator(const _Base& other) noexcept : _Base(other) {}
|
|
|
|
constexpr _const_const_list_iterator &operator++() noexcept override { _Base::_curr == _Base::_curr->_next; return *this; }
|
|
constexpr _const_const_list_iterator &operator--() noexcept override { _Base::_curr == _Base::_curr->_prev; return *this; }
|
|
constexpr _const_const_list_iterator operator++(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_next; return tmp; }
|
|
constexpr _const_const_list_iterator operator--(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_prev; return tmp; }
|
|
};
|
|
|
|
template<typename N, typename Alloc = statically_allocated>
|
|
requires std::derived_from<N, const_list_node>
|
|
class const_list {
|
|
|
|
public:
|
|
|
|
using value_type = N;
|
|
using size_type = std::size_t;
|
|
using difference_type = std::ptrdiff_t;
|
|
using reference = value_type&;
|
|
using const_reference = const value_type&;
|
|
using pointer = value_type *;
|
|
using const_pointer = const value_type *;
|
|
using iterator = _const_list_iterator<N>;
|
|
using const_iterator = _const_const_list_iterator<N>;
|
|
using reverse_iterator = std::reverse_iterator<iterator>;
|
|
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
|
|
|
|
|
private:
|
|
const_list_node *_start;
|
|
const_list_node *_end;
|
|
std::size_t _size;
|
|
|
|
constexpr const_list() noexcept = default;
|
|
constexpr explicit const_list(size_type count) noexcept;
|
|
constexpr const_list(size_type count, const value_type& value) noexcept;
|
|
template<std::input_iterator InputIt>
|
|
constexpr const_list(InputIt first, InputIt last);
|
|
constexpr const_list(const const_list& other) noexcept;
|
|
constexpr const_list(const_list&& other) noexcept;
|
|
constexpr const_list(std::initializer_list<value_type> init) noexcept;
|
|
|
|
constexpr ~const_list();
|
|
|
|
constexpr const_list& operator=(const const_list& other);
|
|
constexpr const_list& operator=(const_list&& other);
|
|
constexpr const_list& operator=(std::initializer_list<N> init);
|
|
|
|
constexpr void assign(size_type count, const value_type& value) noexcept;
|
|
template<std::input_iterator InputIt>
|
|
constexpr void assign(InputIt first, InputIt last);
|
|
constexpr void assign(std::initializer_list<value_type> values);
|
|
|
|
[[nodiscard]] constexpr reference front() noexcept{ return *_start; }
|
|
[[nodiscard]] constexpr const_reference front() const noexcept { return *_start; }
|
|
|
|
[[nodiscard]] constexpr reference back() noexcept { return _end; }
|
|
[[nodiscard]] constexpr const_reference back() const noexcept { return _end; }
|
|
|
|
[[nodiscard]] constexpr iterator begin() noexcept { return iterator(_start); };
|
|
[[nodiscard]] constexpr const_iterator begin() const noexcept { return const_iterator(_start); };
|
|
[[nodiscard]] constexpr const_iterator cbegin() const noexcept { return const_iterator(_start); };
|
|
|
|
[[nodiscard]] constexpr iterator end() noexcept { return iterator(); };
|
|
[[nodiscard]] constexpr const_iterator end() const noexcept { return const_iterator(); };
|
|
[[nodiscard]] constexpr const_iterator cend() const noexcept { return const_iterator(); };
|
|
|
|
[[nodiscard]] constexpr reverse_iterator rbegin() noexcept { return std::reverse_iterator<iterator>(end()); };
|
|
[[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept { return std::reverse_iterator<const_iterator>(end()); };
|
|
[[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept { return std::reverse_iterator<const_iterator>(end()); };
|
|
|
|
[[nodiscard]] constexpr reverse_iterator rend() noexcept { return std::reverse_iterator<iterator>(begin()); };
|
|
[[nodiscard]] constexpr const_reverse_iterator rend() const noexcept { return std::reverse_iterator<const_iterator>(begin()); };
|
|
[[nodiscard]] constexpr const_reverse_iterator crend() const noexcept { return std::reverse_iterator<const_iterator>(begin()); };
|
|
|
|
[[nodiscard]] constexpr bool empty() const noexcept { return _size == 0; }
|
|
[[nodiscard]] constexpr size_type max_size() const noexcept { return SIZE_MAX; }
|
|
|
|
void clear() noexcept;
|
|
|
|
constexpr iterator insert(const_iterator pos, const value_type& value);
|
|
constexpr iterator insert(const_iterator pos, value_type&& value);
|
|
constexpr iterator insert(const_iterator pos, size_type count, const value_type& value);
|
|
template<std::input_iterator InputIt>
|
|
constexpr iterator insert(const_iterator pos, InputIt first, InputIt last);
|
|
constexpr iterator insert(const_iterator pos, std::initializer_list<value_type> values);
|
|
|
|
template<typename ...Args>
|
|
constexpr iterator emplace(const_iterator pos, Args&&... args);
|
|
|
|
constexpr iterator erase(const_iterator pos);
|
|
constexpr iterator erase(const_iterator first, const_iterator last);
|
|
|
|
constexpr void push_back(const value_type& value);
|
|
constexpr void push_back(value_type&& value);
|
|
|
|
template<typename ...Args>
|
|
constexpr reference emplace_back(Args&&... args);
|
|
|
|
constexpr void pop_back();
|
|
|
|
constexpr void push_front(const value_type& value);
|
|
constexpr void push_front(value_type&& value);
|
|
|
|
template<typename ...Args>
|
|
constexpr reference emplace_front(Args&&... args);
|
|
|
|
constexpr void pop_front();
|
|
|
|
constexpr void resize(size_type count);
|
|
constexpr void resize(size_type count, const value_type& value);
|
|
|
|
constexpr void swap(const_list& other) noexcept;
|
|
|
|
constexpr void merge(const_list& other);
|
|
constexpr void merge(const_list&& other);
|
|
template<typename Compare>
|
|
constexpr void merge(const_list& other, Compare comp);
|
|
template<typename Compare>
|
|
constexpr void merge(const_list&& other, Compare comp);
|
|
|
|
constexpr void splice(const_iterator pos, const_list& other);
|
|
constexpr void splice(const_iterator pos, const_list&& other);
|
|
constexpr void splice(const_iterator pos, const_list& other, const_iterator it);
|
|
constexpr void splice(const_iterator pos, const_list&& other, const_iterator it);
|
|
constexpr void splice(const_iterator pos, const_list& other, const_iterator first, const_iterator last);
|
|
constexpr void splice(const_iterator pos, const_list&& other, const_iterator first, const_iterator last);
|
|
|
|
constexpr size_type remove(const value_type& value);
|
|
template<typename UnaryPredicate>
|
|
size_type remove_if(UnaryPredicate p);
|
|
|
|
void reverse() noexcept;
|
|
|
|
size_type unique();
|
|
template<typename BinaryPredicate>
|
|
constexpr size_type unique(BinaryPredicate p);
|
|
|
|
constexpr void sort();
|
|
template<typename Compare>
|
|
void sort(Compare comp);
|
|
|
|
};
|
|
|
|
class const_list_node {
|
|
private:
|
|
const_list_node *_prev;
|
|
const_list_node *_next;
|
|
|
|
friend class const_list<const_list_node>;
|
|
friend class _const_list_iterator_base<const_list_node>;
|
|
};
|
|
|
|
|
|
template<std::input_iterator InputIt>
|
|
const_list(InputIt, InputIt) -> const_list<typename std::iterator_traits<InputIt>::value_type>;
|
|
|
|
template<typename N1, typename N2, typename Alloc1, typename Alloc2>
|
|
constexpr bool operator==(const const_list<N1, Alloc1>& lhs,
|
|
const const_list<N2, Alloc2>& rhs)
|
|
{
|
|
return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
|
|
}
|
|
|
|
template<typename N1, typename N2, typename Alloc1, typename Alloc2>
|
|
constexpr auto operator<=>(const const_list<N1, Alloc1>& lhs,
|
|
const const_list<N2, Alloc2>& rhs)
|
|
{
|
|
return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
constexpr void swap(const const_list<N, Alloc>& lhs,
|
|
const const_list<N, Alloc>& rhs)
|
|
{
|
|
lhs.swap(rhs);
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
constexpr const_list<N, Alloc>::size_type erase(const_list<N, Alloc>& c, const N& value)
|
|
{
|
|
c.remove(value);
|
|
}
|
|
|
|
template<typename N, typename Alloc, typename Pred>
|
|
constexpr const_list<N, Alloc>::size_type erase(const_list<N, Alloc>& c, Pred pred)
|
|
{
|
|
c.remove_if(pred);
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr
|
|
const_list<N, Alloc>::const_list(const_list::size_type count) noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr
|
|
const_list<N, Alloc>::const_list(const_list::size_type count, const value_type &value) noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<std::input_iterator InputIt>
|
|
constexpr const_list<N, Alloc>::const_list(InputIt first, InputIt last)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr
|
|
const_list<N, Alloc>::const_list(const const_list &other) noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr
|
|
const_list<N, Alloc>::const_list(const_list &&other) noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr
|
|
const_list<N, Alloc>::const_list(std::initializer_list<value_type> init) noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list<N, Alloc>::~const_list()
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list &
|
|
const_list<N, Alloc>::operator=(const const_list &other)
|
|
{
|
|
return <#initializer#>;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list &
|
|
const_list<N, Alloc>::operator=(const_list &&other)
|
|
{
|
|
return <#initializer#>;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list &
|
|
const_list<N, Alloc>::operator=(std::initializer_list<N> init)
|
|
{
|
|
return <#initializer#>;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::assign(const_list::size_type count, const value_type &value) noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<std::input_iterator InputIt>
|
|
constexpr void const_list<N, Alloc>::assign(InputIt first, InputIt last)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::assign(std::initializer_list<value_type> values)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>void const_list<N, Alloc>::clear() noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list::iterator
|
|
const_list<N, Alloc>::insert(const_list::const_iterator pos, const value_type &value)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list::iterator
|
|
const_list<N, Alloc>::insert(const_list::const_iterator pos, value_type &&value)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list::iterator
|
|
const_list<N, Alloc>::insert(const_list::const_iterator pos, const_list::size_type count, const value_type &value)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<std::input_iterator InputIt>
|
|
constexpr const_list::iterator
|
|
const_list<N, Alloc>::insert(const_list::const_iterator pos, InputIt first, InputIt last)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list::iterator
|
|
const_list<N, Alloc>::insert(const_list::const_iterator pos, std::initializer_list<value_type> values)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename... Args>
|
|
constexpr const_list::iterator const_list<N, Alloc>::emplace(const_list::const_iterator pos, Args &&... args)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list::iterator
|
|
const_list<N, Alloc>::erase(const_list::const_iterator pos)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list::iterator
|
|
const_list<N, Alloc>::erase(const_list::const_iterator first, const_list::const_iterator last)
|
|
{
|
|
return cc::const_list::iterator();
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::push_back(const value_type &value)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::push_back(value_type &&value)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename... Args>
|
|
constexpr reference const_list<N, Alloc>::emplace_back(Args &&... args)
|
|
{
|
|
return <#initializer#>;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::pop_back()
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::push_front(const value_type &value)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::push_front(value_type &&value)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename... Args>
|
|
constexpr reference const_list<N, Alloc>::emplace_front(Args &&... args)
|
|
{
|
|
return <#initializer#>;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::pop_front()
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::resize(const_list::size_type count)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::resize(const_list::size_type count, const value_type &value)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::swap(const_list &other) noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::merge(const_list &other)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::merge(const_list &&other)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename Compare>
|
|
constexpr void const_list<N, Alloc>::merge(const_list &other, Compare comp)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename Compare>
|
|
constexpr void const_list<N, Alloc>::merge(const_list &&other, Compare comp)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::splice(const_list::const_iterator pos, const_list &other)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::splice(const_list::const_iterator pos, const_list &&other)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::splice(const_list::const_iterator pos, const_list &other, const_list::const_iterator it)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::splice(const_list::const_iterator pos, const_list &&other, const_list::const_iterator it)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::splice(const_list::const_iterator pos, const_list &other, const_list::const_iterator first,
|
|
const_list::const_iterator last)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void
|
|
const_list<N, Alloc>::splice(const_list::const_iterator pos, const_list &&other, const_list::const_iterator first,
|
|
const_list::const_iterator last)
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr const_list::size_type
|
|
const_list<N, Alloc>::remove(const value_type &value)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename UnaryPredicate>
|
|
const_list::size_type const_list<N, Alloc>::remove_if(UnaryPredicate p)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>void const_list<N, Alloc>::reverse() noexcept
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>const_list::size_type const_list<N, Alloc>::unique()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename BinaryPredicate>
|
|
constexpr const_list::size_type const_list<N, Alloc>::unique(BinaryPredicate p)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>constexpr void const_list<N, Alloc>::sort()
|
|
{
|
|
|
|
}
|
|
|
|
template<typename N, typename Alloc>
|
|
requires std::derived_from<N, const_list_node>
|
|
template<typename Compare>
|
|
void const_list<N, Alloc>::sort(Compare comp)
|
|
{
|
|
|
|
}
|
|
|
|
} // cc
|
|
|
|
#endif //UDIFF_CONST_LIST_H_
|