feat: add some sk_ header

Signed-off-by: Niu Zhihong <zhihong@nzhnb.com>

Author: MRNIU

src/libcxx/include/sk_list

@@ -0,0 +1,215 @@
+/**
+ * @copyright Copyright The SimpleKernel Contributors
+ */
+
+#ifndef SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_LIST_
+#define SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_LIST_
+
+#include <cstddef>
+#include <new>
+
+namespace sk_std {
+
+struct list_node_base {
+  list_node_base* prev;
+  list_node_base* next;
+
+  list_node_base() : prev(this), next(this) {}
+};
+
+template <typename T>
+struct list_node : public list_node_base {
+  T data;
+
+  list_node(const T& val) : list_node_base(), data(val) {}
+};
+
+template <typename T>
+class list_iterator {
+ public:
+  using node_type = list_node<T>;
+  using base_node_type = list_node_base;
+  using self_type = list_iterator<T>;
+  using value_type = T;
+  using pointer = T*;
+  using reference = T&;
+
+  base_node_type* node;
+
+  list_iterator(base_node_type* n) : node(n) {}
+
+  reference operator*() const { return static_cast<node_type*>(node)->data; }
+  pointer operator->() const { return &static_cast<node_type*>(node)->data; }
+
+  self_type& operator++() {
+    node = node->next;
+    return *this;
+  }
+
+  self_type operator++(int) {
+    self_type tmp = *this;
+    node = node->next;
+    return tmp;
+  }
+
+  self_type& operator--() {
+    node = node->prev;
+    return *this;
+  }
+
+  self_type operator--(int) {
+    self_type tmp = *this;
+    node = node->prev;
+    return tmp;
+  }
+
+  bool operator==(const self_type& other) const { return node == other.node; }
+  bool operator!=(const self_type& other) const { return node != other.node; }
+};
+
+template <typename T>
+class list_const_iterator {
+ public:
+  using node_type = list_node<T>;
+  using base_node_type = list_node_base;
+  using self_type = list_const_iterator<T>;
+  using value_type = T;
+  using pointer = const T*;
+  using reference = const T&;
+
+  const base_node_type* node;
+
+  list_const_iterator(const base_node_type* n) : node(n) {}
+
+  reference operator*() const {
+    return static_cast<const node_type*>(node)->data;
+  }
+  pointer operator->() const {
+    return &static_cast<const node_type*>(node)->data;
+  }
+
+  self_type& operator++() {
+    node = node->next;
+    return *this;
+  }
+
+  self_type operator++(int) {
+    self_type tmp = *this;
+    node = node->next;
+    return tmp;
+  }
+
+  self_type& operator--() {
+    node = node->prev;
+    return *this;
+  }
+
+  self_type operator--(int) {
+    self_type tmp = *this;
+    node = node->prev;
+    return tmp;
+  }
+
+  bool operator==(const self_type& other) const { return node == other.node; }
+  bool operator!=(const self_type& other) const { return node != other.node; }
+};
+
+template <typename T>
+class list {
+ public:
+  using node_type = list_node<T>;
+  using base_node_type = list_node_base;
+  using iterator = list_iterator<T>;
+  using const_iterator = list_const_iterator<T>;
+  using value_type = T;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using size_type = size_t;
+
+  list() : _size(0) {
+    // Sentinel already initialized by default ctor of list_node_base
+  }
+
+  ~list() { clear(); }
+
+  list(const list& other) : _size(0) {
+    for (const auto& item : other) {
+      push_back(item);
+    }
+  }
+
+  list& operator=(const list& other) {
+    if (this != &other) {
+      clear();
+      for (const auto& item : other) {
+        push_back(item);
+      }
+    }
+    return *this;
+  }
+
+  iterator begin() { return iterator(sentinel.next); }
+  iterator end() { return iterator(&sentinel); }
+  const_iterator begin() const { return const_iterator(sentinel.next); }
+  const_iterator end() const { return const_iterator(&sentinel); }
+
+  bool empty() const { return _size == 0; }
+  size_type size() const { return _size; }
+
+  T& front() { return *begin(); }
+  const T& front() const { return *begin(); }
+  T& back() { return *(--end()); }
+  const T& back() const { return *(--end()); }
+
+  void push_front(const T& val) { insert(begin(), val); }
+
+  void push_back(const T& val) { insert(end(), val); }
+
+  void pop_front() { erase(begin()); }
+
+  void pop_back() { erase(--end()); }
+
+  iterator insert(iterator pos, const T& val) {
+    node_type* new_node = new node_type(val);
+    base_node_type* p = pos.node;
+    base_node_type* prev = p->prev;
+
+    new_node->next = p;
+    new_node->prev = prev;
+    prev->next = new_node;
+    p->prev = new_node;
+
+    _size++;
+    return iterator(new_node);
+  }
+
+  iterator erase(iterator pos) {
+    if (pos == end()) return end();
+
+    base_node_type* p = pos.node;
+    base_node_type* prev = p->prev;
+    base_node_type* next = p->next;
+
+    prev->next = next;
+    next->prev = prev;
+
+    delete static_cast<node_type*>(p);
+
+    _size--;
+    return iterator(next);
+  }
+
+  void clear() {
+    while (!empty()) {
+      pop_front();
+    }
+  }
+
+ private:
+  list_node_base sentinel;
+  size_type _size;
+};
+
+}  // namespace sk_std
+
+#endif  // SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_LIST_

src/libcxx/include/sk_priority_queue

@@ -0,0 +1,70 @@
+/**
+ * @copyright Copyright The SimpleKernel Contributors
+ */
+
+#ifndef SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_PRIORITY_QUEUE_
+#define SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_PRIORITY_QUEUE_
+
+#include <algorithm>
+#include <functional>
+
+#include "sk_vector"
+
+namespace sk_std {
+
+template <class T, class Container = vector<T>,
+          class Compare = std::less<typename Container::value_type>>
+class priority_queue {
+ public:
+  using value_type = typename Container::value_type;
+  using reference = typename Container::reference;
+  using const_reference = typename Container::const_reference;
+  using size_type = typename Container::size_type;
+  using container_type = Container;
+
+ protected:
+  Container c;
+  Compare comp;
+
+ public:
+  priority_queue() : c(), comp() {}
+
+  explicit priority_queue(const Compare& compare) : c(), comp(compare) {}
+
+  priority_queue(const Compare& compare, const Container& cont)
+      : c(cont), comp(compare) {
+    std::make_heap(c.begin(), c.end(), comp);
+  }
+
+  priority_queue(const Compare& compare, Container&& cont)
+      : c(static_cast<Container&&>(cont)), comp(compare) {
+    std::make_heap(c.begin(), c.end(), comp);
+  }
+
+  bool empty() const { return c.size() == 0; }
+
+  size_type size() const { return c.size(); }
+
+  const_reference top() const { return c.front(); }
+
+  void push(const value_type& value) {
+    c.push_back(value);
+    std::push_heap(c.begin(), c.end(), comp);
+  }
+
+  void push(value_type&& value) {
+    c.push_back(static_cast<value_type&&>(value));
+    std::push_heap(c.begin(), c.end(), comp);
+  }
+
+  void pop() {
+    if (c.size() > 0) {
+      std::pop_heap(c.begin(), c.end(), comp);
+      c.pop_back();
+    }
+  }
+};
+
+}  // namespace sk_std
+
+#endif  // SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_PRIORITY_QUEUE_

src/libcxx/include/sk_queue

@@ -0,0 +1,54 @@
+/**
+ * @copyright Copyright The SimpleKernel Contributors
+ */
+
+#ifndef SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_QUEUE_
+#define SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_QUEUE_
+
+#include "sk_list"
+
+namespace sk_std {
+
+template <class T, class Container = list<T>>
+class queue {
+ public:
+  using value_type = typename Container::value_type;
+  using reference = typename Container::reference;
+  using const_reference = typename Container::const_reference;
+  using size_type = typename Container::size_type;
+  using container_type = Container;
+
+ protected:
+  Container c;
+
+ public:
+  explicit queue(const Container& cont = Container()) : c(cont) {}
+
+  ~queue() = default;
+
+  queue(const queue&) = default;
+  queue(queue&&) = default;
+
+  queue& operator=(const queue&) = default;
+  queue& operator=(queue&&) = default;
+
+  bool empty() const { return c.empty(); }
+
+  size_type size() const { return c.size(); }
+
+  reference front() { return c.front(); }
+
+  const_reference front() const { return c.front(); }
+
+  reference back() { return c.back(); }
+
+  const_reference back() const { return c.back(); }
+
+  void push(const value_type& val) { c.push_back(val); }
+
+  void pop() { c.pop_front(); }
+};
+
+}  // namespace sk_std
+
+#endif  // SIMPLEKERNEL_SRC_LIBCXX_INCLUDE_SK_QUEUE_