mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-23 04:50:17 +00:00
format
This commit is contained in:
blueloveTH
parent
9b3e6bb177
commit
ed3e7856e8
@ -1,25 +1,25 @@
|
||||
#pragma once
|
||||
|
||||
#include <cassert>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <memory>
|
||||
|
||||
#include "pocketpy/common/traits.hpp"
|
||||
#include "pocketpy/common/types.hpp"
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cassert>
|
||||
#include <memory>
|
||||
namespace pkpy {
|
||||
|
||||
namespace pkpy{
|
||||
|
||||
template<typename T>
|
||||
struct array{
|
||||
template <typename T>
|
||||
struct array {
|
||||
T* _data;
|
||||
int _size;
|
||||
|
||||
using size_type = int;
|
||||
|
||||
array(): _data(nullptr), _size(0) {}
|
||||
array(int size): _data((T*)std::malloc(sizeof(T) * size)), _size(size) {}
|
||||
array(array&& other) noexcept: _data(other._data), _size(other._size) {
|
||||
array() : _data(nullptr), _size(0) {}
|
||||
array(int size) : _data((T*)std::malloc(sizeof(T) * size)), _size(size) {}
|
||||
array(array&& other) noexcept : _data(other._data), _size(other._size) {
|
||||
other._data = nullptr;
|
||||
other._size = 0;
|
||||
}
|
||||
@ -27,12 +27,12 @@ struct array{
|
||||
array(explicit_copy_t, const array& other) {
|
||||
_data = (T*)std::malloc(sizeof(T) * 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];
|
||||
}
|
||||
array(T* data, int size): _data(data), _size(size) {}
|
||||
array(T* data, int size) : _data(data), _size(size) {}
|
||||
|
||||
array& operator=(array&& other) noexcept{
|
||||
if(_data){
|
||||
array& operator=(array&& other) noexcept {
|
||||
if (_data) {
|
||||
std::destroy(begin(), end());
|
||||
std::free(_data);
|
||||
}
|
||||
@ -57,8 +57,8 @@ struct array{
|
||||
|
||||
int size() const { return _size; }
|
||||
|
||||
T* begin() const{ return _data; }
|
||||
T* end() const{ return _data + _size; }
|
||||
T* begin() const { return _data; }
|
||||
T* end() const { return _data + _size; }
|
||||
T* data() const { return _data; }
|
||||
|
||||
std::pair<T*, int> detach() noexcept {
|
||||
@ -69,42 +69,43 @@ struct array{
|
||||
}
|
||||
|
||||
~array() {
|
||||
if(_data){
|
||||
if (_data) {
|
||||
std::destroy(begin(), end());
|
||||
std::free(_data);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<typename T>
|
||||
struct vector{
|
||||
template <typename T>
|
||||
struct vector {
|
||||
T* _data;
|
||||
int _capacity;
|
||||
int _size;
|
||||
|
||||
using size_type = int;
|
||||
|
||||
vector(): _data(nullptr), _capacity(0), _size(0) {}
|
||||
vector(int size):
|
||||
_data((T*)std::malloc(sizeof(T) * size)),
|
||||
_capacity(size), _size(size) {}
|
||||
vector(vector&& other) noexcept:
|
||||
_data(other._data), _capacity(other._capacity), _size(other._size) {
|
||||
vector() : _data(nullptr), _capacity(0), _size(0) {}
|
||||
vector(int size)
|
||||
: _data((T*)std::malloc(sizeof(T) * size)),
|
||||
_capacity(size),
|
||||
_size(size) {}
|
||||
vector(vector&& other) noexcept
|
||||
: _data(other._data), _capacity(other._capacity), _size(other._size) {
|
||||
other._data = nullptr;
|
||||
other._capacity = 0;
|
||||
other._size = 0;
|
||||
}
|
||||
vector(const vector& other) = delete;
|
||||
vector(explicit_copy_t, const vector& other):
|
||||
_data((T*)std::malloc(sizeof(T) * other._size)),
|
||||
_capacity(other._size), _size(other._size) {
|
||||
for(int i=0; i<_size; i++) _data[i] = other._data[i];
|
||||
vector(explicit_copy_t, const vector& other)
|
||||
: _data((T*)std::malloc(sizeof(T) * other._size)),
|
||||
_capacity(other._size),
|
||||
_size(other._size) {
|
||||
for (int i = 0; i < _size; i++) _data[i] = other._data[i];
|
||||
}
|
||||
|
||||
// allow move
|
||||
vector& operator=(vector&& other) noexcept{
|
||||
if(_data){
|
||||
vector& operator=(vector&& other) noexcept {
|
||||
if (_data) {
|
||||
std::destroy(begin(), end());
|
||||
std::free(_data);
|
||||
}
|
||||
@ -117,87 +118,88 @@ struct vector{
|
||||
bool empty() const { return _size == 0; }
|
||||
int size() const { return _size; }
|
||||
int capacity() const { return _capacity; }
|
||||
T& back() { return _data[_size-1]; }
|
||||
T& back() { return _data[_size - 1]; }
|
||||
|
||||
T* begin() const { return _data; }
|
||||
T* end() const { return _data + _size; }
|
||||
T* data() const { return _data; }
|
||||
|
||||
void reserve(int cap){
|
||||
if(cap < 4) cap = 4; // minimum capacity
|
||||
if(cap <= capacity()) return;
|
||||
void reserve(int cap) {
|
||||
if (cap < 4) cap = 4; // minimum capacity
|
||||
if (cap <= capacity()) return;
|
||||
T* new_data = (T*)std::malloc(sizeof(T) * cap);
|
||||
if constexpr(is_trivially_relocatable_v<T>){
|
||||
if constexpr (is_trivially_relocatable_v<T>) {
|
||||
std::memcpy(new_data, _data, sizeof(T) * _size);
|
||||
}else{
|
||||
for(int i=0; i<_size; i++){
|
||||
new(&new_data[i]) T(std::move(_data[i]));
|
||||
} else {
|
||||
for (int i = 0; i < _size; i++) {
|
||||
new (&new_data[i]) T(std::move(_data[i]));
|
||||
_data[i].~T();
|
||||
}
|
||||
}
|
||||
if(_data) std::free(_data);
|
||||
if (_data) std::free(_data);
|
||||
_data = new_data;
|
||||
_capacity = cap;
|
||||
}
|
||||
|
||||
void resize(int size){
|
||||
void resize(int size) {
|
||||
reserve(size);
|
||||
_size = size;
|
||||
}
|
||||
|
||||
void push_back(const T& t){
|
||||
if(_size == _capacity) reserve(_capacity * 2);
|
||||
void push_back(const T& t) {
|
||||
if (_size == _capacity) reserve(_capacity * 2);
|
||||
new (&_data[_size++]) T(t);
|
||||
}
|
||||
|
||||
void push_back(T&& t){
|
||||
if(_size == _capacity) reserve(_capacity * 2);
|
||||
new(&_data[_size++]) T(std::move(t));
|
||||
void push_back(T&& t) {
|
||||
if (_size == _capacity) reserve(_capacity * 2);
|
||||
new (&_data[_size++]) T(std::move(t));
|
||||
}
|
||||
|
||||
bool contains(const T& t) const {
|
||||
for(int i=0; i<_size; i++){
|
||||
if(_data[i] == t) return true;
|
||||
for (int i = 0; i < _size; i++) {
|
||||
if (_data[i] == t) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
void emplace_back(Args&&... args){
|
||||
if(_size == _capacity) reserve(_capacity * 2);
|
||||
new(&_data[_size++]) T(std::forward<Args>(args)...);
|
||||
template <typename... Args>
|
||||
void emplace_back(Args&&... args) {
|
||||
if (_size == _capacity) reserve(_capacity * 2);
|
||||
new (&_data[_size++]) T(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
T& operator[](int i) { return _data[i]; }
|
||||
const T& operator[](int i) const { return _data[i]; }
|
||||
|
||||
void extend(T* begin, T* end){
|
||||
void extend(T* begin, T* end) {
|
||||
int n = end - begin;
|
||||
reserve(_size + n);
|
||||
for(int i=0; i<n; i++) new(&_data[_size++]) T(begin[i]);
|
||||
for (int i = 0; i < n; i++) new (&_data[_size++]) T(begin[i]);
|
||||
}
|
||||
|
||||
void insert(int index, const T& t){
|
||||
if(_size == _capacity) reserve(_capacity * 2);
|
||||
for(int i=_size; i>index; i--) _data[i] = std::move(_data[i-1]);
|
||||
void insert(int index, const T& t) {
|
||||
if (_size == _capacity) reserve(_capacity * 2);
|
||||
for (int i = _size; i > index; i--) _data[i] = std::move(_data[i - 1]);
|
||||
_data[index] = t;
|
||||
_size++;
|
||||
}
|
||||
|
||||
void erase(int index){
|
||||
for(int i=index; i<_size-1; i++) _data[i] = std::move(_data[i+1]);
|
||||
void erase(int index) {
|
||||
for (int i = index; i < _size - 1; i++)
|
||||
_data[i] = std::move(_data[i + 1]);
|
||||
_size--;
|
||||
}
|
||||
|
||||
void pop_back(){
|
||||
void pop_back() {
|
||||
assert(_size > 0);
|
||||
_size--;
|
||||
if constexpr(!std::is_trivially_destructible_v<T>){
|
||||
if constexpr (!std::is_trivially_destructible_v<T>) {
|
||||
_data[_size].~T();
|
||||
}
|
||||
}
|
||||
|
||||
void clear(){
|
||||
void clear() {
|
||||
std::destroy(begin(), end());
|
||||
_size = 0;
|
||||
}
|
||||
@ -210,45 +212,50 @@ struct vector{
|
||||
return retval;
|
||||
}
|
||||
|
||||
void swap(vector& other){
|
||||
void swap(vector& other) {
|
||||
std::swap(_data, other._data);
|
||||
std::swap(_capacity, other._capacity);
|
||||
std::swap(_size, other._size);
|
||||
}
|
||||
|
||||
~vector(){
|
||||
if(_data){
|
||||
~vector() {
|
||||
if (_data) {
|
||||
std::destroy(begin(), end());
|
||||
std::free(_data);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T, typename Container=vector<T>>
|
||||
class stack{
|
||||
Container vec;
|
||||
public:
|
||||
void push(const T& t){ vec.push_back(t); }
|
||||
void push(T&& t){ vec.push_back(std::move(t)); }
|
||||
template<typename... Args>
|
||||
void emplace(Args&&... args){
|
||||
template <typename T, typename Container = vector<T>>
|
||||
class stack {
|
||||
Container vec;
|
||||
|
||||
public:
|
||||
void push(const T& t) { vec.push_back(t); }
|
||||
void push(T&& t) { vec.push_back(std::move(t)); }
|
||||
template <typename... Args>
|
||||
void emplace(Args&&... args) {
|
||||
vec.emplace_back(std::forward<Args>(args)...);
|
||||
}
|
||||
void pop(){ vec.pop_back(); }
|
||||
void clear(){ vec.clear(); }
|
||||
bool empty() const { return vec.empty(); }
|
||||
typename Container::size_type size() const { return vec.size(); }
|
||||
T& top(){ return vec.back(); }
|
||||
const T& top() const { return vec.back(); }
|
||||
T popx(){ T t = std::move(vec.back()); vec.pop_back(); return t; }
|
||||
void reserve(int n){ vec.reserve(n); }
|
||||
Container& container() { return vec; }
|
||||
void pop() { vec.pop_back(); }
|
||||
void clear() { vec.clear(); }
|
||||
bool empty() const { return vec.empty(); }
|
||||
typename Container::size_type size() const { return vec.size(); }
|
||||
T& top() { return vec.back(); }
|
||||
const T& top() const { return vec.back(); }
|
||||
T popx() {
|
||||
T t = std::move(vec.back());
|
||||
vec.pop_back();
|
||||
return t;
|
||||
}
|
||||
void reserve(int n) { vec.reserve(n); }
|
||||
Container& container() { return vec; }
|
||||
const Container& container() const { return vec; }
|
||||
};
|
||||
|
||||
template <typename T, typename Container=vector<T>>
|
||||
class stack_no_copy: public stack<T, Container>{
|
||||
public:
|
||||
template <typename T, typename Container = vector<T>>
|
||||
class stack_no_copy : public stack<T, Container> {
|
||||
public:
|
||||
stack_no_copy() = default;
|
||||
stack_no_copy(const stack_no_copy& other) = delete;
|
||||
stack_no_copy& operator=(const stack_no_copy& other) = delete;
|
||||
@ -256,210 +263,183 @@ public:
|
||||
stack_no_copy& operator=(stack_no_copy&& other) noexcept = default;
|
||||
};
|
||||
|
||||
} // namespace pkpy
|
||||
|
||||
} // namespace pkpy
|
||||
|
||||
namespace pkpy {
|
||||
template<typename T, std::size_t N>
|
||||
class small_vector
|
||||
{
|
||||
alignas(T) char m_buffer[sizeof(T) * N];
|
||||
T* m_begin;
|
||||
T* m_end;
|
||||
T* m_max;
|
||||
template <typename T, std::size_t N>
|
||||
class small_vector {
|
||||
alignas(T) char m_buffer[sizeof(T) * N];
|
||||
T* m_begin;
|
||||
T* m_end;
|
||||
T* m_max;
|
||||
|
||||
public:
|
||||
using value_type = T;
|
||||
using size_type = int;
|
||||
using difference_type = int;
|
||||
using reference = T&;
|
||||
using const_reference = const T&;
|
||||
using pointer = T*;
|
||||
using const_pointer = const T*;
|
||||
using iterator = T*;
|
||||
using const_iterator = const T*;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
public:
|
||||
using value_type = T;
|
||||
using size_type = int;
|
||||
using difference_type = int;
|
||||
using reference = T&;
|
||||
using const_reference = const T&;
|
||||
using pointer = T*;
|
||||
using const_pointer = const T*;
|
||||
using iterator = T*;
|
||||
using const_iterator = const T*;
|
||||
using reverse_iterator = std::reverse_iterator<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]] size_type size() const { return m_end - m_begin; }
|
||||
[[nodiscard]] size_type capacity() const { return m_max - m_begin; }
|
||||
[[nodiscard]] bool empty() const { return m_begin == m_end; }
|
||||
[[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 capacity() const { return m_max - m_begin; }
|
||||
[[nodiscard]] bool empty() const { return m_begin == m_end; }
|
||||
|
||||
pointer data() { return m_begin; }
|
||||
const_pointer data() const { return m_begin; }
|
||||
reference operator[](size_type index) { return m_begin[index]; }
|
||||
const_reference operator[](size_type index) const { return m_begin[index]; }
|
||||
iterator begin() { return m_begin; }
|
||||
const_iterator begin() const { return m_begin; }
|
||||
iterator end() { return m_end; }
|
||||
const_iterator end() const { return m_end; }
|
||||
reference front() { return *begin(); }
|
||||
const_reference front() const { return *begin(); }
|
||||
reference back() { return *(end() - 1); }
|
||||
const_reference back() const { return *(end() - 1); }
|
||||
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
||||
const_reverse_iterator rbegin() const
|
||||
{
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
reverse_iterator rend() { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rend() const
|
||||
{
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
private:
|
||||
static void uninitialized_copy_n(const void* src, size_type n, void* dest)
|
||||
{
|
||||
if constexpr (std::is_trivially_copyable_v<T>)
|
||||
{
|
||||
std::memcpy(dest, src, sizeof(T) * n);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (size_type i = 0; i < n; i++)
|
||||
{
|
||||
::new((T*) dest + i) T(*((const T*) src + i));
|
||||
}
|
||||
pointer data() { return m_begin; }
|
||||
const_pointer data() const { return m_begin; }
|
||||
reference operator[](size_type index) { return m_begin[index]; }
|
||||
const_reference operator[](size_type index) const { return m_begin[index]; }
|
||||
iterator begin() { return m_begin; }
|
||||
const_iterator begin() const { return m_begin; }
|
||||
iterator end() { return m_end; }
|
||||
const_iterator end() const { return m_end; }
|
||||
reference front() { return *begin(); }
|
||||
const_reference front() const { return *begin(); }
|
||||
reference back() { return *(end() - 1); }
|
||||
const_reference back() const { return *(end() - 1); }
|
||||
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
||||
const_reverse_iterator rbegin() const {
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
reverse_iterator rend() { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rend() const {
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
private:
|
||||
static void uninitialized_copy_n(const void* src, size_type n, void* dest) {
|
||||
if constexpr (std::is_trivially_copyable_v<T>) {
|
||||
std::memcpy(dest, src, sizeof(T) * n);
|
||||
} else {
|
||||
for (size_type i = 0; i < n; i++) {
|
||||
::new ((T*)dest + i) T(*((const T*)src + i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void uninitialized_relocate_n(void* src, size_type n, void* dest)
|
||||
{
|
||||
if constexpr (is_trivially_relocatable_v<T>)
|
||||
{
|
||||
std::memcpy(dest, src, sizeof(T) * n);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (size_type i = 0; i < n; i++)
|
||||
{
|
||||
::new((T*) dest + i) T(std::move(*((T*) src + i)));
|
||||
((T*) src + i)->~T();
|
||||
}
|
||||
static void uninitialized_relocate_n(void* src, size_type n, void* dest) {
|
||||
if constexpr (is_trivially_relocatable_v<T>) {
|
||||
std::memcpy(dest, src, sizeof(T) * n);
|
||||
} else {
|
||||
for (size_type i = 0; i < n; i++) {
|
||||
::new ((T*)dest + i) T(std::move(*((T*)src + i)));
|
||||
((T*)src + i)->~T();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
small_vector() : m_begin(reinterpret_cast<T*>(m_buffer)), m_end(m_begin), m_max(m_begin + N) {}
|
||||
public:
|
||||
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
|
||||
{
|
||||
const auto size = other.size();
|
||||
const auto capacity = other.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);
|
||||
m_end = m_begin + size;
|
||||
m_max = m_begin + capacity;
|
||||
small_vector(const small_vector& other) noexcept {
|
||||
const auto size = other.size();
|
||||
const auto capacity = other.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);
|
||||
m_end = m_begin + size;
|
||||
m_max = m_begin + capacity;
|
||||
}
|
||||
|
||||
small_vector(small_vector&& other) noexcept {
|
||||
if (other.is_small()) {
|
||||
m_begin = reinterpret_cast<T*>(m_buffer);
|
||||
uninitialized_relocate_n(other.m_buffer, other.size(), m_buffer);
|
||||
m_end = m_begin + other.size();
|
||||
m_max = m_begin + N;
|
||||
} else {
|
||||
m_begin = other.m_begin;
|
||||
m_end = other.m_end;
|
||||
m_max = other.m_max;
|
||||
}
|
||||
other.m_begin = reinterpret_cast<T*>(other.m_buffer);
|
||||
other.m_end = other.m_begin;
|
||||
other.m_max = other.m_begin + N;
|
||||
}
|
||||
|
||||
small_vector(small_vector&& other) noexcept
|
||||
{
|
||||
if(other.is_small())
|
||||
{
|
||||
m_begin = reinterpret_cast<T*>(m_buffer);
|
||||
uninitialized_relocate_n(other.m_buffer, other.size(), m_buffer);
|
||||
m_end = m_begin + other.size();
|
||||
m_max = m_begin + N;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_begin = other.m_begin;
|
||||
m_end = other.m_end;
|
||||
m_max = other.m_max;
|
||||
}
|
||||
other.m_begin = reinterpret_cast<T*>(other.m_buffer);
|
||||
other.m_end = other.m_begin;
|
||||
other.m_max = other.m_begin + N;
|
||||
small_vector& operator=(const small_vector& other) noexcept {
|
||||
if (this != &other) {
|
||||
~small_vector();
|
||||
::new (this) small_vector(other);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
small_vector& operator=(const small_vector& other) noexcept
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
~small_vector();
|
||||
::new (this) small_vector(other);
|
||||
}
|
||||
return *this;
|
||||
small_vector& operator=(small_vector&& other) noexcept {
|
||||
if (this != &other) {
|
||||
~small_vector();
|
||||
::new (this) small_vector(std::move(other));
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
small_vector& operator=(small_vector&& other) noexcept
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
~small_vector();
|
||||
:: new (this) small_vector(std::move(other));
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
~small_vector() {
|
||||
std::destroy(m_begin, m_end);
|
||||
if (!is_small()) std::free(m_begin);
|
||||
}
|
||||
|
||||
~small_vector()
|
||||
{
|
||||
std::destroy(m_begin, m_end);
|
||||
if (!is_small()) std::free(m_begin);
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
void emplace_back(Args&& ...args) noexcept
|
||||
{
|
||||
if (m_end == m_max)
|
||||
{
|
||||
const auto new_capacity = capacity() * 2;
|
||||
const auto size = this->size();
|
||||
if (!is_small())
|
||||
{
|
||||
if constexpr (is_trivially_relocatable_v<T>)
|
||||
{
|
||||
m_begin = (pointer)std::realloc(m_begin, sizeof(T) * new_capacity);
|
||||
}
|
||||
else
|
||||
{
|
||||
auto new_data = (pointer) std::malloc(sizeof(T) * new_capacity);
|
||||
uninitialized_relocate_n(m_begin, size, new_data);
|
||||
std::free(m_begin);
|
||||
m_begin = new_data;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
auto new_data = (pointer) std::malloc(sizeof(T) * new_capacity);
|
||||
uninitialized_relocate_n(m_buffer, size, new_data);
|
||||
template <typename... Args>
|
||||
void emplace_back(Args&&... args) noexcept {
|
||||
if (m_end == m_max) {
|
||||
const auto new_capacity = capacity() * 2;
|
||||
const auto size = this->size();
|
||||
if (!is_small()) {
|
||||
if constexpr (is_trivially_relocatable_v<T>) {
|
||||
m_begin = (pointer)std::realloc(m_begin,
|
||||
sizeof(T) * new_capacity);
|
||||
} else {
|
||||
auto new_data =
|
||||
(pointer)std::malloc(sizeof(T) * new_capacity);
|
||||
uninitialized_relocate_n(m_begin, size, new_data);
|
||||
std::free(m_begin);
|
||||
m_begin = new_data;
|
||||
}
|
||||
m_end = m_begin + size;
|
||||
m_max = m_begin + new_capacity;
|
||||
} else {
|
||||
auto new_data = (pointer)std::malloc(sizeof(T) * new_capacity);
|
||||
uninitialized_relocate_n(m_buffer, size, new_data);
|
||||
m_begin = new_data;
|
||||
}
|
||||
::new(m_end) T(std::forward<Args>(args)...);
|
||||
m_end++;
|
||||
m_end = m_begin + size;
|
||||
m_max = m_begin + new_capacity;
|
||||
}
|
||||
::new (m_end) T(std::forward<Args>(args)...);
|
||||
m_end++;
|
||||
}
|
||||
|
||||
void push_back(const T& value) { emplace_back(value); }
|
||||
void push_back(T&& value) { emplace_back(std::move(value)); }
|
||||
void push_back(const T& value) { emplace_back(value); }
|
||||
void push_back(T&& value) { emplace_back(std::move(value)); }
|
||||
|
||||
void pop_back()
|
||||
{
|
||||
m_end--;
|
||||
if constexpr (!std::is_trivially_destructible_v<T>)
|
||||
{
|
||||
m_end->~T();
|
||||
}
|
||||
void pop_back() {
|
||||
m_end--;
|
||||
if constexpr (!std::is_trivially_destructible_v<T>) {
|
||||
m_end->~T();
|
||||
}
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
std::destroy(m_begin, m_end);
|
||||
m_end = m_begin;
|
||||
}
|
||||
};
|
||||
void clear() {
|
||||
std::destroy(m_begin, m_end);
|
||||
m_end = m_begin;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
class small_vector_2: public small_vector<T, N>
|
||||
{
|
||||
public:
|
||||
small_vector_2() = default;
|
||||
small_vector_2(const small_vector_2& other) = delete;
|
||||
small_vector_2& operator=(const small_vector_2& other) = delete;
|
||||
small_vector_2(small_vector_2&& other) = delete;
|
||||
small_vector_2& operator=(small_vector_2&& other) = delete;
|
||||
};
|
||||
} // namespace pkpy
|
||||
template <typename T, std::size_t N>
|
||||
class small_vector_2 : public small_vector<T, N> {
|
||||
public:
|
||||
small_vector_2() = default;
|
||||
small_vector_2(const small_vector_2& other) = delete;
|
||||
small_vector_2& operator=(const small_vector_2& other) = delete;
|
||||
small_vector_2(small_vector_2&& other) = delete;
|
||||
small_vector_2& operator=(small_vector_2&& other) = delete;
|
||||
};
|
||||
} // namespace pkpy
|
||||
Loading…
x
Reference in New Issue
Block a user