Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2025-10-23 21:10:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

format

Browse Source
This commit is contained in:
blueloveTH 2024-06-02 21:57:15 +08:00
parent 9b3e6bb177
commit ed3e7856e8
1 changed files with 246 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
include/pocketpy/common/vector.hpp
View File

@ -1,13 +1,13 @@
#pragma once #pragma once
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <memory>
#include "pocketpy/common/traits.hpp" #include "pocketpy/common/traits.hpp"
#include "pocketpy/common/types.hpp" #include "pocketpy/common/types.hpp"
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <memory>
namespace pkpy { namespace pkpy {
template <typename T> template <typename T>
@ -76,7 +76,6 @@ struct array{
} }
}; };
template <typename T> template <typename T>
struct vector { struct vector {
T* _data; T* _data;
@ -86,19 +85,21 @@ struct vector{
using size_type = int; using size_type = int;
vector() : _data(nullptr), _capacity(0), _size(0) {} vector() : _data(nullptr), _capacity(0), _size(0) {}
vector(int size): vector(int size)
_data((T*)std::malloc(sizeof(T) * size)), : _data((T*)std::malloc(sizeof(T) * size)),
_capacity(size), _size(size) {} _capacity(size),
vector(vector&& other) noexcept: _size(size) {}
_data(other._data), _capacity(other._capacity), _size(other._size) { vector(vector&& other) noexcept
: _data(other._data), _capacity(other._capacity), _size(other._size) {
other._data = nullptr; other._data = nullptr;
other._capacity = 0; other._capacity = 0;
other._size = 0; other._size = 0;
} }
vector(const vector& other) = delete; vector(const vector& other) = delete;
vector(explicit_copy_t, const vector& other): vector(explicit_copy_t, const vector& other)
_data((T*)std::malloc(sizeof(T) * other._size)), : _data((T*)std::malloc(sizeof(T) * other._size)),
_capacity(other._size), _size(other._size) { _capacity(other._size),
_size(other._size) {
for (int i = 0; i < _size; i++) _data[i] = other._data[i]; for (int i = 0; i < _size; i++) _data[i] = other._data[i];
} }
@ -185,7 +186,8 @@ struct vector{
} }
void erase(int index) { void erase(int index) {
for(int i=index; i<_size-1; i++) _data[i] = std::move(_data[i+1]); for (int i = index; i < _size - 1; i++)
_data[i] = std::move(_data[i + 1]);
_size--; _size--;
} }
@ -227,6 +229,7 @@ struct vector{
template <typename T, typename Container = vector<T>> template <typename T, typename Container = vector<T>>
class stack { class stack {
Container vec; Container vec;
public: public:
void push(const T& t) { vec.push_back(t); } void push(const T& t) { vec.push_back(t); }
void push(T&& t) { vec.push_back(std::move(t)); } void push(T&& t) { vec.push_back(std::move(t)); }
@ -240,7 +243,11 @@ public:
typename Container::size_type size() const { return vec.size(); } typename Container::size_type size() const { return vec.size(); }
T& top() { return vec.back(); } T& top() { return vec.back(); }
const T& top() const { return vec.back(); } const T& top() const { return vec.back(); }
T popx(){ T t = std::move(vec.back()); vec.pop_back(); return t; } T popx() {
T t = std::move(vec.back());
vec.pop_back();
return t;
}
void reserve(int n) { vec.reserve(n); } void reserve(int n) { vec.reserve(n); }
Container& container() { return vec; } Container& container() { return vec; }
const Container& container() const { return vec; } const Container& container() const { return vec; }
@ -258,11 +265,9 @@ public:
} // namespace pkpy } // namespace pkpy
namespace pkpy { namespace pkpy {
template <typename T, std::size_t N> template <typename T, std::size_t N>
class small_vector class small_vector {
{
alignas(T) char m_buffer[sizeof(T) * N]; alignas(T) char m_buffer[sizeof(T) * N];
T* m_begin; T* m_begin;
T* m_end; T* m_end;
@ -281,7 +286,9 @@ namespace pkpy {
using reverse_iterator = std::reverse_iterator<iterator>; using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>;
[[nodiscard]] bool is_small() const { return m_begin == reinterpret_cast<const T*>(m_buffer); } [[nodiscard]] bool is_small() const {
return m_begin == reinterpret_cast<const T*>(m_buffer);
}
[[nodiscard]] size_type size() const { return m_end - m_begin; } [[nodiscard]] size_type size() const { return m_end - m_begin; }
[[nodiscard]] size_type capacity() const { return m_max - m_begin; } [[nodiscard]] size_type capacity() const { return m_max - m_begin; }
[[nodiscard]] bool empty() const { return m_begin == m_end; } [[nodiscard]] bool empty() const { return m_begin == m_end; }
@ -299,41 +306,30 @@ namespace pkpy {
reference back() { return *(end() - 1); } reference back() { return *(end() - 1); }
const_reference back() const { return *(end() - 1); } const_reference back() const { return *(end() - 1); }
reverse_iterator rbegin() { return reverse_iterator(end()); } reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const const_reverse_iterator rbegin() const {
{
return const_reverse_iterator(end()); return const_reverse_iterator(end());
} }
reverse_iterator rend() { return reverse_iterator(begin()); } reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const const_reverse_iterator rend() const {
{
return const_reverse_iterator(begin()); return const_reverse_iterator(begin());
} }
private: private:
static void uninitialized_copy_n(const void* src, size_type n, void* dest) static void uninitialized_copy_n(const void* src, size_type n, void* dest) {
{ if constexpr (std::is_trivially_copyable_v<T>) {
if constexpr (std::is_trivially_copyable_v<T>)
{
std::memcpy(dest, src, sizeof(T) * n); std::memcpy(dest, src, sizeof(T) * n);
} } else {
else for (size_type i = 0; i < n; i++) {
{
for (size_type i = 0; i < n; i++)
{
::new ((T*)dest + i) T(*((const T*)src + i)); ::new ((T*)dest + i) T(*((const T*)src + i));
} }
} }
} }
static void uninitialized_relocate_n(void* src, size_type n, void* dest) static void uninitialized_relocate_n(void* src, size_type n, void* dest) {
{ if constexpr (is_trivially_relocatable_v<T>) {
if constexpr (is_trivially_relocatable_v<T>)
{
std::memcpy(dest, src, sizeof(T) * n); std::memcpy(dest, src, sizeof(T) * n);
} } else {
else for (size_type i = 0; i < n; i++) {
{
for (size_type i = 0; i < n; i++)
{
::new ((T*)dest + i) T(std::move(*((T*)src + i))); ::new ((T*)dest + i) T(std::move(*((T*)src + i)));
((T*)src + i)->~T(); ((T*)src + i)->~T();
} }
@ -341,29 +337,28 @@ namespace pkpy {
} }
public: public:
small_vector() : m_begin(reinterpret_cast<T*>(m_buffer)), m_end(m_begin), m_max(m_begin + N) {} small_vector()
: m_begin(reinterpret_cast<T*>(m_buffer)),
m_end(m_begin),
m_max(m_begin + N) {}
small_vector(const small_vector& other) noexcept small_vector(const small_vector& other) noexcept {
{
const auto size = other.size(); const auto size = other.size();
const auto capacity = other.capacity(); const auto capacity = other.capacity();
m_begin = reinterpret_cast<T*>(other.is_small() ? m_buffer : std::malloc(sizeof(T) * capacity)); m_begin = reinterpret_cast<T*>(
other.is_small() ? m_buffer : std::malloc(sizeof(T) * capacity));
uninitialized_copy_n(other.m_begin, size, this->m_begin); uninitialized_copy_n(other.m_begin, size, this->m_begin);
m_end = m_begin + size; m_end = m_begin + size;
m_max = m_begin + capacity; m_max = m_begin + capacity;
} }
small_vector(small_vector&& other) noexcept small_vector(small_vector&& other) noexcept {
{ if (other.is_small()) {
if(other.is_small())
{
m_begin = reinterpret_cast<T*>(m_buffer); m_begin = reinterpret_cast<T*>(m_buffer);
uninitialized_relocate_n(other.m_buffer, other.size(), m_buffer); uninitialized_relocate_n(other.m_buffer, other.size(), m_buffer);
m_end = m_begin + other.size(); m_end = m_begin + other.size();
m_max = m_begin + N; m_max = m_begin + N;
} } else {
else
{
m_begin = other.m_begin; m_begin = other.m_begin;
m_end = other.m_end; m_end = other.m_end;
m_max = other.m_max; m_max = other.m_max;
@ -373,55 +368,44 @@ namespace pkpy {
other.m_max = other.m_begin + N; other.m_max = other.m_begin + N;
} }
small_vector& operator=(const small_vector& other) noexcept small_vector& operator=(const small_vector& other) noexcept {
{ if (this != &other) {
if (this != &other)
{
~small_vector(); ~small_vector();
::new (this) small_vector(other); ::new (this) small_vector(other);
} }
return *this; return *this;
} }
small_vector& operator=(small_vector&& other) noexcept small_vector& operator=(small_vector&& other) noexcept {
{ if (this != &other) {
if (this != &other)
{
~small_vector(); ~small_vector();
::new (this) small_vector(std::move(other)); ::new (this) small_vector(std::move(other));
} }
return *this; return *this;
} }
~small_vector() ~small_vector() {
{
std::destroy(m_begin, m_end); std::destroy(m_begin, m_end);
if (!is_small()) std::free(m_begin); if (!is_small()) std::free(m_begin);
} }
template <typename... Args> template <typename... Args>
void emplace_back(Args&& ...args) noexcept void emplace_back(Args&&... args) noexcept {
{ if (m_end == m_max) {
if (m_end == m_max)
{
const auto new_capacity = capacity() * 2; const auto new_capacity = capacity() * 2;
const auto size = this->size(); const auto size = this->size();
if (!is_small()) if (!is_small()) {
{ if constexpr (is_trivially_relocatable_v<T>) {
if constexpr (is_trivially_relocatable_v<T>) m_begin = (pointer)std::realloc(m_begin,
{ sizeof(T) * new_capacity);
m_begin = (pointer)std::realloc(m_begin, sizeof(T) * new_capacity); } else {
} auto new_data =
else (pointer)std::malloc(sizeof(T) * new_capacity);
{
auto new_data = (pointer) std::malloc(sizeof(T) * new_capacity);
uninitialized_relocate_n(m_begin, size, new_data); uninitialized_relocate_n(m_begin, size, new_data);
std::free(m_begin); std::free(m_begin);
m_begin = new_data; m_begin = new_data;
} }
} } else {
else
{
auto new_data = (pointer)std::malloc(sizeof(T) * new_capacity); auto new_data = (pointer)std::malloc(sizeof(T) * new_capacity);
uninitialized_relocate_n(m_buffer, size, new_data); uninitialized_relocate_n(m_buffer, size, new_data);
m_begin = new_data; m_begin = new_data;
@ -436,25 +420,21 @@ namespace pkpy {
void push_back(const T& value) { emplace_back(value); } void push_back(const T& value) { emplace_back(value); }
void push_back(T&& value) { emplace_back(std::move(value)); } void push_back(T&& value) { emplace_back(std::move(value)); }
void pop_back() void pop_back() {
{
m_end--; m_end--;
if constexpr (!std::is_trivially_destructible_v<T>) if constexpr (!std::is_trivially_destructible_v<T>) {
{
m_end->~T(); m_end->~T();
} }
} }
void clear() void clear() {
{
std::destroy(m_begin, m_end); std::destroy(m_begin, m_end);
m_end = m_begin; m_end = m_begin;
} }
}; };
template <typename T, std::size_t N> template <typename T, std::size_t N>
class small_vector_2: public small_vector<T, N> class small_vector_2 : public small_vector<T, N> {
{
public: public:
small_vector_2() = default; small_vector_2() = default;
small_vector_2(const small_vector_2& other) = delete; small_vector_2(const small_vector_2& other) = delete;