added every list member function

include/const_list.h

@@ -6,6 +6,7 @@
 #define UDIFF_CONST_LIST_H_
 
 #include <concepts>
+#include <initializer_list>
 #include <iterator>
 
 namespace cc {
@@ -19,11 +20,12 @@ namespace cc {
 			N *_curr;
 
 		public:
-			constexpr _const_list_iterator_base() : _curr() {}
+			constexpr _const_list_iterator_base() noexcept : _curr() {}
-			constexpr explicit _const_list_iterator_base(N *curr) : _curr(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 { 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;
@@ -37,8 +39,9 @@ namespace cc {
 	class _const_list_iterator : public _const_list_iterator_base<N> {
 			using _Base = _const_list_iterator_base<N>;
 		public:
-			constexpr _const_list_iterator() : _Base() {}
+			constexpr _const_list_iterator() noexcept : _Base() {}
-			constexpr explicit _const_list_iterator(N *curr) : _Base(curr) {}
+			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; }
@@ -55,6 +58,7 @@ namespace cc {
 		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; }
@@ -83,6 +87,117 @@ namespace cc {
 			
 		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);
 
     };
 
@@ -96,6 +211,41 @@ namespace cc {
 	};
 
 
+    template<std::input_iterator InputIt>
+    const_list(InputIt, InputIt) -> const_list<typename std::iterator_traits<InputIt>::value_type>;
+
+    template<typename N1, typename N2>
+    constexpr bool operator==(const const_list<N1>& lhs,
+                              const const_list<N2>& rhs)
+    {
+
+    }
+
+    template<typename N1, typename N2>
+    constexpr auto operator<=>(const const_list<N1>& lhs,
+                               const const_list<N2>& rhs)
+    {
+
+    }
+
+    template<typename N>
+    constexpr void swap(const const_list<N>& lhs,
+                        const const_list<N>& rhs)
+    {
+
+    }
+
+    template<typename N>
+    constexpr const_list<N>::size_type erase(const_list<N>& c, const N& value)
+    {
+
+    }
+
+    template<typename N, typename Pred>
+    constexpr const_list<N>::size_type erase(const_list<N>& c, Pred pred)
+    {
+
+    }
 
 } // cc