mirror of
https://github.com/EnderIce2/Fennix.git
synced 2025-07-01 02:19:15 +00:00
790 lines
18 KiB
Plaintext
790 lines
18 KiB
Plaintext
/*
|
|
This file is part of Fennix Kernel.
|
|
|
|
Fennix Kernel 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.
|
|
|
|
Fennix Kernel 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 Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
#include <functional>
|
|
#include <initializer_list>
|
|
#include <compare>
|
|
#include <iterator>
|
|
#include <limits>
|
|
#include <utility>
|
|
#include <type_traits>
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
namespace std
|
|
{
|
|
template <class T, class Allocator = std::allocator<T>>
|
|
class forward_list
|
|
{
|
|
public:
|
|
using value_type = T;
|
|
using allocator_type = Allocator;
|
|
using size_type = std::size_t;
|
|
using difference_type = std::ptrdiff_t;
|
|
using reference = value_type &;
|
|
using const_reference = const value_type &;
|
|
using pointer = std::allocator_traits<Allocator>::pointer;
|
|
using const_pointer = std::allocator_traits<Allocator>::const_pointer;
|
|
using iterator_category = std::forward_iterator_tag;
|
|
// using iterator = value_type;
|
|
// using const_iterator = const value_type;
|
|
|
|
private:
|
|
struct node
|
|
{
|
|
node *Next;
|
|
value_type Value;
|
|
|
|
template <class... Args>
|
|
node(node *next, Args &&...args)
|
|
: Next(next), Value(std::forward<Args>(args)...) {}
|
|
};
|
|
|
|
using node_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<node>;
|
|
node_allocator_type NodeAlloc;
|
|
node *Head; /* Points to dummy node (before first element) */
|
|
|
|
node *__CreateNode(const T &value)
|
|
{
|
|
node *n = std::allocator_traits<node_allocator_type>::allocate(NodeAlloc, 1);
|
|
try
|
|
{
|
|
std::allocator_traits<node_allocator_type>::construct(NodeAlloc, n, nullptr, value);
|
|
}
|
|
catch (...)
|
|
{
|
|
std::allocator_traits<node_allocator_type>::deallocate(NodeAlloc, n, 1);
|
|
throw;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
node *__CreateNode(T &&value)
|
|
{
|
|
node *n = std::allocator_traits<node_allocator_type>::allocate(NodeAlloc, 1);
|
|
try
|
|
{
|
|
std::allocator_traits<node_allocator_type>::construct(NodeAlloc, n, nullptr, std::move(value));
|
|
}
|
|
catch (...)
|
|
{
|
|
std::allocator_traits<node_allocator_type>::deallocate(NodeAlloc, n, 1);
|
|
throw;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
template <class... Args>
|
|
node *__CreateNodeEmplace(Args &&...args)
|
|
{
|
|
node *n = std::allocator_traits<node_allocator_type>::allocate(NodeAlloc, 1);
|
|
try
|
|
{
|
|
std::allocator_traits<node_allocator_type>::construct(NodeAlloc, n, nullptr, std::forward<Args>(args)...);
|
|
}
|
|
catch (...)
|
|
{
|
|
std::allocator_traits<node_allocator_type>::deallocate(NodeAlloc, n, 1);
|
|
throw;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
void __DestroyNode(node *n)
|
|
{
|
|
std::allocator_traits<node_allocator_type>::destroy(NodeAlloc, n);
|
|
std::allocator_traits<node_allocator_type>::deallocate(NodeAlloc, n, 1);
|
|
}
|
|
|
|
void __ClearNodes(node *start)
|
|
{
|
|
while (start)
|
|
{
|
|
node *next = start->Next;
|
|
__DestroyNode(start);
|
|
start = next;
|
|
}
|
|
}
|
|
|
|
public:
|
|
class iterator
|
|
{
|
|
friend class forward_list;
|
|
node *ptr;
|
|
|
|
public:
|
|
typedef std::forward_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef std::ptrdiff_t difference_type;
|
|
typedef T *pointer;
|
|
typedef T &reference;
|
|
using self_type = iterator;
|
|
|
|
iterator() : ptr(nullptr) {}
|
|
iterator(node *p) : ptr(p) {}
|
|
iterator(const iterator &other) = default;
|
|
iterator &operator=(const iterator &other) = default;
|
|
~iterator() = default;
|
|
|
|
reference operator*() { return ptr->Value; }
|
|
pointer operator->() { return &(ptr->Value); }
|
|
const_reference operator*() const { return ptr->Value; }
|
|
const_pointer operator->() const { return &(ptr->Value); }
|
|
|
|
self_type &operator++()
|
|
{
|
|
ptr = ptr->Next;
|
|
return *this;
|
|
}
|
|
|
|
self_type operator++(int)
|
|
{
|
|
self_type tmp = *this;
|
|
++(*this);
|
|
return tmp;
|
|
}
|
|
|
|
bool operator==(const self_type &other) const { return ptr == other.ptr; }
|
|
bool operator!=(const self_type &other) const { return ptr != other.ptr; }
|
|
};
|
|
|
|
class const_iterator
|
|
{
|
|
friend class forward_list;
|
|
const node *ptr;
|
|
|
|
public:
|
|
typedef std::forward_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef std::ptrdiff_t difference_type;
|
|
typedef const T *pointer;
|
|
typedef const T &reference;
|
|
using self_type = const_iterator;
|
|
|
|
const_iterator() : ptr(nullptr) {}
|
|
const_iterator(const node *p) : ptr(p) {}
|
|
const_iterator(const iterator &it) : ptr(it.ptr) {}
|
|
const_iterator(const const_iterator &other) = default;
|
|
const_iterator &operator=(const const_iterator &other) = default;
|
|
~const_iterator() = default;
|
|
|
|
reference operator*() const { return ptr->Value; }
|
|
pointer operator->() const { return &(ptr->Value); }
|
|
|
|
self_type &operator++()
|
|
{
|
|
ptr = ptr->Next;
|
|
return *this;
|
|
}
|
|
|
|
self_type operator++(int)
|
|
{
|
|
self_type tmp = *this;
|
|
++(*this);
|
|
return tmp;
|
|
}
|
|
|
|
bool operator==(const self_type &other) const { return ptr == other.ptr; }
|
|
bool operator!=(const self_type &other) const { return ptr != other.ptr; }
|
|
};
|
|
|
|
#pragma region Constructors
|
|
|
|
forward_list() : NodeAlloc(), Head(__CreateNodeEmplace()) {}
|
|
|
|
explicit forward_list(const Allocator &alloc) : NodeAlloc(alloc), Head(__CreateNodeEmplace()) {}
|
|
|
|
explicit forward_list(size_type count, const Allocator &alloc = Allocator())
|
|
: NodeAlloc(alloc), Head(__CreateNodeEmplace())
|
|
{
|
|
node *cur = Head;
|
|
for (size_type i = 0; i < count; ++i)
|
|
{
|
|
cur->Next = __CreateNode(T());
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
forward_list(size_type count, const T &value, const Allocator &alloc = Allocator())
|
|
: NodeAlloc(alloc), Head(__CreateNodeEmplace())
|
|
{
|
|
node *cur = Head;
|
|
for (size_type i = 0; i < count; ++i)
|
|
{
|
|
cur->Next = __CreateNode(value);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
template <class InputIt, typename = std::enable_if_t<!std::is_integral<InputIt>::value>>
|
|
forward_list(InputIt first, InputIt last, const Allocator &alloc = Allocator())
|
|
: NodeAlloc(alloc), Head(__CreateNodeEmplace())
|
|
{
|
|
node *cur = Head;
|
|
for (; first != last; ++first)
|
|
{
|
|
cur->Next = __CreateNode(*first);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
forward_list(const forward_list &other)
|
|
: NodeAlloc(std::allocator_traits<Allocator>::select_on_container_copy_construction(other.NodeAlloc)), Head(__CreateNodeEmplace())
|
|
{
|
|
node *cur = Head;
|
|
for (node *n = other.Head->Next; n; n = n->Next)
|
|
{
|
|
cur->Next = __CreateNode(n->Value);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
forward_list(forward_list &&other)
|
|
: NodeAlloc(std::move(other.NodeAlloc)), Head(other.Head)
|
|
{
|
|
other.Head = nullptr;
|
|
}
|
|
|
|
forward_list(const forward_list &other, const std::type_identity_t<Allocator> &alloc)
|
|
: NodeAlloc(alloc), Head(__CreateNodeEmplace())
|
|
{
|
|
node *cur = Head;
|
|
for (node *n = other.Head->Next; n; n = n->Next)
|
|
{
|
|
cur->Next = __CreateNode(n->Value);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
forward_list(forward_list &&other, const std::type_identity_t<Allocator> &alloc)
|
|
: NodeAlloc(alloc), Head(__CreateNodeEmplace())
|
|
{
|
|
if (other.empty())
|
|
return;
|
|
|
|
node *cur = Head;
|
|
for (node *n = other.Head->Next; n; n = n->Next)
|
|
{
|
|
cur->Next = __CreateNode(std::move(n->Value));
|
|
cur = cur->Next;
|
|
}
|
|
other.clear();
|
|
}
|
|
|
|
forward_list(std::initializer_list<T> init, const Allocator &alloc = Allocator())
|
|
: NodeAlloc(alloc), Head(__CreateNodeEmplace())
|
|
{
|
|
node *cur = Head;
|
|
for (const auto &v : init)
|
|
{
|
|
cur->Next = __CreateNode(v);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
~forward_list()
|
|
{
|
|
if (Head == nullptr)
|
|
return;
|
|
|
|
clear();
|
|
__DestroyNode(Head);
|
|
Head = nullptr;
|
|
}
|
|
|
|
#pragma endregion Constructors
|
|
|
|
forward_list &operator=(const forward_list &other)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
clear();
|
|
node *cur = Head;
|
|
for (node *n = other.Head->Next; n; n = n->Next)
|
|
{
|
|
cur->Next = __CreateNode(n->Value);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
forward_list &operator=(forward_list &&other) noexcept(std::allocator_traits<Allocator>::is_always_equal::value)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
clear();
|
|
__DestroyNode(Head);
|
|
Head = other.Head;
|
|
NodeAlloc = std::move(other.NodeAlloc);
|
|
other.Head = nullptr;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
forward_list &operator=(std::initializer_list<value_type> ilist)
|
|
{
|
|
clear();
|
|
node *cur = Head;
|
|
for (const auto &v : ilist)
|
|
{
|
|
cur->Next = __CreateNode(v);
|
|
cur = cur->Next;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void assign(size_type count, const T &value)
|
|
{
|
|
clear();
|
|
node *cur = Head;
|
|
for (size_type i = 0; i < count; ++i)
|
|
{
|
|
cur->Next = __CreateNode(value);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
template <class InputIt>
|
|
void assign(InputIt first, InputIt last)
|
|
{
|
|
clear();
|
|
node *cur = Head;
|
|
for (; first != last; ++first)
|
|
{
|
|
cur->Next = __CreateNode(*first);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
void assign(std::initializer_list<T> ilist)
|
|
{
|
|
clear();
|
|
node *cur = Head;
|
|
for (const auto &v : ilist)
|
|
{
|
|
cur->Next = __CreateNode(v);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
allocator_type get_allocator() const noexcept { return allocator_type(NodeAlloc); }
|
|
|
|
#pragma region Element Access
|
|
|
|
reference front() { return Head->Next->Value; }
|
|
const_reference front() const { return Head->Next->Value; }
|
|
|
|
#pragma endregion Element Access
|
|
|
|
#pragma region Iterators
|
|
|
|
iterator before_begin() noexcept { return iterator(Head); }
|
|
const_iterator before_begin() const noexcept { return const_iterator(Head); }
|
|
const_iterator cbefore_begin() const noexcept { return const_iterator(Head); }
|
|
|
|
iterator begin() noexcept { return Head ? iterator(Head->Next) : iterator(nullptr); }
|
|
const_iterator begin() const noexcept { return Head ? const_iterator(Head->Next) : iterator(nullptr); }
|
|
const_iterator cbegin() const noexcept { return Head ? const_iterator(Head->Next) : iterator(nullptr); }
|
|
|
|
iterator end() noexcept { return iterator(nullptr); }
|
|
const_iterator end() const noexcept { return const_iterator(nullptr); }
|
|
const_iterator cend() const noexcept { return const_iterator(nullptr); }
|
|
|
|
#pragma endregion Iterators
|
|
|
|
#pragma region Capacity
|
|
|
|
bool empty() const noexcept { return Head->Next == nullptr; }
|
|
size_type max_size() const noexcept { return std::numeric_limits<size_type>::max(); }
|
|
|
|
#pragma endregion Capacity
|
|
|
|
#pragma region Modifiers
|
|
|
|
void clear() noexcept
|
|
{
|
|
node *cur = Head->Next;
|
|
Head->Next = nullptr;
|
|
__ClearNodes(cur);
|
|
}
|
|
|
|
iterator insert_after(const_iterator pos, const T &value)
|
|
{
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *n = __CreateNode(value);
|
|
n->Next = p->Next;
|
|
p->Next = n;
|
|
return iterator(n);
|
|
}
|
|
|
|
iterator insert_after(const_iterator pos, T &&value)
|
|
{
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *n = __CreateNode(std::move(value));
|
|
n->Next = p->Next;
|
|
p->Next = n;
|
|
return iterator(n);
|
|
}
|
|
|
|
iterator insert_after(const_iterator pos, size_type count, const T &value)
|
|
{
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *last = p;
|
|
|
|
for (size_type i = 0; i < count; ++i)
|
|
{
|
|
node *n = __CreateNode(value);
|
|
n->Next = last->Next;
|
|
last->Next = n;
|
|
last = n;
|
|
}
|
|
|
|
return iterator(last);
|
|
}
|
|
|
|
template <class InputIt>
|
|
iterator insert_after(const_iterator pos, InputIt first, InputIt last)
|
|
{
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *cur = p;
|
|
|
|
for (; first != last; ++first)
|
|
{
|
|
node *n = __CreateNode(*first);
|
|
n->Next = cur->Next;
|
|
cur->Next = n;
|
|
cur = n;
|
|
}
|
|
|
|
return iterator(cur);
|
|
}
|
|
|
|
iterator insert_after(const_iterator pos, std::initializer_list<T> ilist)
|
|
{
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *cur = p;
|
|
|
|
for (const auto &v : ilist)
|
|
{
|
|
node *n = __CreateNode(v);
|
|
n->Next = cur->Next;
|
|
cur->Next = n;
|
|
cur = n;
|
|
}
|
|
|
|
return iterator(cur);
|
|
}
|
|
|
|
template <class... Args>
|
|
iterator emplace_after(const_iterator pos, Args &&...args)
|
|
{
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *n = __CreateNodeEmplace(std::forward<Args>(args)...);
|
|
n->Next = p->Next;
|
|
p->Next = n;
|
|
return iterator(n);
|
|
}
|
|
|
|
iterator erase_after(const_iterator pos)
|
|
{
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *to_delete = p->Next;
|
|
|
|
if (to_delete)
|
|
{
|
|
p->Next = to_delete->Next;
|
|
__DestroyNode(to_delete);
|
|
}
|
|
|
|
return iterator(p->Next);
|
|
}
|
|
|
|
iterator erase_after(const_iterator first, const_iterator last)
|
|
{
|
|
node *p = const_cast<node *>(first.ptr);
|
|
node *end = const_cast<node *>(last.ptr);
|
|
node *cur = p->Next;
|
|
|
|
while (cur != end)
|
|
{
|
|
node *next = cur->Next;
|
|
__DestroyNode(cur);
|
|
cur = next;
|
|
}
|
|
|
|
p->Next = end;
|
|
return iterator(end);
|
|
}
|
|
|
|
void push_front(const T &value) { insert_after(before_begin(), value); }
|
|
void push_front(T &&value) { insert_after(before_begin(), std::move(value)); }
|
|
|
|
template <class... Args>
|
|
reference emplace_front(Args &&...args)
|
|
{
|
|
iterator it = emplace_after(before_begin(), std::forward<Args>(args)...);
|
|
return *it;
|
|
}
|
|
|
|
void pop_front() { erase_after(before_begin()); }
|
|
|
|
void resize(size_type count) { resize(count, T()); }
|
|
|
|
void resize(size_type count, const value_type &value)
|
|
{
|
|
node *cur = Head;
|
|
size_type n = 0;
|
|
|
|
while (cur->Next && n < count)
|
|
{
|
|
cur = cur->Next;
|
|
++n;
|
|
}
|
|
|
|
if (n == count)
|
|
{
|
|
/* Remove remaining */
|
|
__ClearNodes(cur->Next);
|
|
cur->Next = nullptr;
|
|
}
|
|
else
|
|
{
|
|
/* Add more */
|
|
for (; n < count; ++n)
|
|
{
|
|
cur->Next = __CreateNode(value);
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
}
|
|
|
|
void swap(forward_list &other) noexcept(std::allocator_traits<Allocator>::is_always_equal::value)
|
|
{
|
|
std::swap(Head, other.Head);
|
|
/* FIXME FIXME FIXME FIXME */
|
|
// std::swap(NodeAlloc, other.NodeAlloc);
|
|
}
|
|
|
|
#pragma endregion Modifiers
|
|
|
|
#pragma region Operations
|
|
|
|
void merge(forward_list &other) { merge(other, std::less<T>()); }
|
|
void merge(forward_list &&other) { merge(other, std::less<T>()); }
|
|
|
|
template <class Compare>
|
|
void merge(forward_list &other, Compare comp)
|
|
{
|
|
if (this == &other)
|
|
return;
|
|
|
|
node *this_prev = Head;
|
|
node *this_cur = Head->Next;
|
|
node *other_cur = other.Head->Next;
|
|
|
|
while (this_cur && other_cur)
|
|
{
|
|
if (comp(other_cur->Value, this_cur->Value))
|
|
{
|
|
node *next = other_cur->Next;
|
|
this_prev->Next = other_cur;
|
|
other_cur->Next = this_cur;
|
|
this_prev = other_cur;
|
|
other_cur = next;
|
|
}
|
|
else
|
|
{
|
|
this_prev = this_cur;
|
|
this_cur = this_cur->Next;
|
|
}
|
|
}
|
|
|
|
if (other_cur)
|
|
this_prev->Next = other_cur;
|
|
|
|
other.Head->Next = nullptr;
|
|
}
|
|
|
|
template <class Compare>
|
|
void merge(forward_list &&other, Compare comp) { merge(other, comp); }
|
|
|
|
void splice_after(const_iterator pos, forward_list &other)
|
|
{
|
|
if (&other == this || other.empty())
|
|
return;
|
|
splice_after(pos, other, other.before_begin(), other.end());
|
|
}
|
|
|
|
void splice_after(const_iterator pos, forward_list &&other) { splice_after(pos, other); }
|
|
void splice_after(const_iterator pos, forward_list &other, const_iterator it) { splice_after(pos, other, it, std::next(it)); }
|
|
void splice_after(const_iterator pos, forward_list &&other, const_iterator it) { splice_after(pos, other, it); }
|
|
|
|
void splice_after(const_iterator pos, forward_list &other, const_iterator first, const_iterator last)
|
|
{
|
|
if (first == last)
|
|
return;
|
|
|
|
node *p = const_cast<node *>(pos.ptr);
|
|
node *f = const_cast<node *>(first.ptr);
|
|
node *l = const_cast<node *>(last.ptr);
|
|
|
|
node *start = f->Next;
|
|
node *end = start;
|
|
|
|
if (!start)
|
|
return;
|
|
|
|
while (end->Next && end->Next != l)
|
|
end = end->Next;
|
|
|
|
f->Next = l;
|
|
node *after = p->Next;
|
|
p->Next = start;
|
|
end->Next = after;
|
|
}
|
|
|
|
void splice_after(const_iterator pos, forward_list &&other, const_iterator first, const_iterator last)
|
|
{
|
|
splice_after(pos, other, first, last);
|
|
}
|
|
|
|
size_type remove(const T &value)
|
|
{
|
|
size_type count = 0;
|
|
node *prev = Head;
|
|
node *cur = Head->Next;
|
|
while (cur)
|
|
{
|
|
if (cur->Value == value)
|
|
{
|
|
node *to_delete = cur;
|
|
prev->Next = cur->Next;
|
|
cur = cur->Next;
|
|
__DestroyNode(to_delete);
|
|
++count;
|
|
}
|
|
else
|
|
{
|
|
prev = cur;
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
template <class UnaryPred>
|
|
size_type remove_if(UnaryPred p)
|
|
{
|
|
size_type count = 0;
|
|
node *prev = Head;
|
|
node *cur = Head->Next;
|
|
while (cur)
|
|
{
|
|
if (p(cur->Value))
|
|
{
|
|
node *to_delete = cur;
|
|
prev->Next = cur->Next;
|
|
cur = cur->Next;
|
|
__DestroyNode(to_delete);
|
|
++count;
|
|
}
|
|
else
|
|
{
|
|
prev = cur;
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
void reverse() noexcept
|
|
{
|
|
node *prev = nullptr;
|
|
node *cur = Head->Next;
|
|
while (cur)
|
|
{
|
|
node *next = cur->Next;
|
|
cur->Next = prev;
|
|
prev = cur;
|
|
cur = next;
|
|
}
|
|
Head->Next = prev;
|
|
}
|
|
|
|
size_type unique() { return unique(std::equal_to<T>()); }
|
|
|
|
template <class BinaryPred>
|
|
size_type unique(BinaryPred p)
|
|
{
|
|
size_type count = 0;
|
|
node *cur = Head->Next;
|
|
while (cur && cur->Next)
|
|
{
|
|
if (p(cur->Value, cur->Next->Value))
|
|
{
|
|
node *to_delete = cur->Next;
|
|
cur->Next = to_delete->Next;
|
|
__DestroyNode(to_delete);
|
|
++count;
|
|
}
|
|
else
|
|
cur = cur->Next;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
void sort() { sort(std::less<T>()); }
|
|
|
|
template <class Compare>
|
|
void sort(Compare comp)
|
|
{
|
|
if (!Head->Next || !Head->Next->Next)
|
|
return;
|
|
|
|
std::vector<T> vec;
|
|
for (node *cur = Head->Next; cur; cur = cur->Next)
|
|
vec.push_back(cur->Value);
|
|
|
|
std::sort(vec.begin(), vec.end(), comp);
|
|
node *cur = Head->Next;
|
|
for (auto &v : vec)
|
|
{
|
|
cur->Value = v;
|
|
cur = cur->Next;
|
|
}
|
|
}
|
|
|
|
#pragma endregion Operations
|
|
};
|
|
|
|
template <class T, class Alloc>
|
|
bool operator==(const std::forward_list<T, Alloc> &lhs, const std::forward_list<T, Alloc> &rhs)
|
|
{
|
|
return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
|
|
}
|
|
|
|
template <class T, class Alloc>
|
|
auto operator<=>(const std::forward_list<T, Alloc> &lhs, const std::forward_list<T, Alloc> &rhs)
|
|
{
|
|
return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), __synth_three_way);
|
|
}
|
|
}
|