Du kannst nicht mehr als 25 Themen auswählen
Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
168 Zeilen
3.0 KiB
168 Zeilen
3.0 KiB
#pragma once
|
|
|
|
#include "gp/functional/bind_front.hpp"
|
|
#include "gp/algorithms/move.hpp"
|
|
#include "gp/containers/buffer.hpp"
|
|
#include "gp/functional/function.hpp"
|
|
|
|
#include <atomic>
|
|
|
|
namespace gp {
|
|
|
|
template<typename T>
|
|
class unique_ptr {
|
|
T* data;
|
|
gp::allocator& owner;
|
|
|
|
unique_ptr(T* _data, gp::allocator& _owner)
|
|
: data(_data)
|
|
, owner(_owner)
|
|
{}
|
|
|
|
void dirty_clear() {
|
|
if(data) {
|
|
data->~T();
|
|
owner.deallocate(data);
|
|
}
|
|
}
|
|
public:
|
|
template<typename ...U>
|
|
static unique_ptr make(gp::allocator& owner, U&&... args) {
|
|
auto ptr = owner.allocate(sizeof(T));
|
|
return unique_ptr(new(ptr) T(gp::forward<U>(args)...), owner);
|
|
}
|
|
|
|
template<typename U>
|
|
unique_ptr<U> cast() {
|
|
auto save = data;
|
|
data = nullptr;
|
|
return unique_ptr<U>(save, owner);
|
|
}
|
|
|
|
T* operator->() {
|
|
return data;
|
|
}
|
|
|
|
T& operator*() {
|
|
return *data;
|
|
}
|
|
|
|
operator bool() {
|
|
return data != nullptr;
|
|
}
|
|
|
|
unique_ptr(unique_ptr&) = delete;
|
|
|
|
unique_ptr(unique_ptr&& oth)
|
|
: data(oth.data)
|
|
, owner(oth.owner)
|
|
{
|
|
oth.data = nullptr;
|
|
}
|
|
|
|
unique_ptr& operator=(unique_ptr&) = delete;
|
|
|
|
unique_ptr& operator=(unique_ptr&& oth) {
|
|
dirty_clear();
|
|
data = oth.data;
|
|
owner = oth.owner;
|
|
}
|
|
|
|
~unique_ptr() {
|
|
dirty_clear();
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
class shared_ptr {
|
|
T* data;
|
|
std::atomic_int* refcounter;
|
|
gp::allocator& owner;
|
|
|
|
shared_ptr(T* _data, gp::allocator& _owner)
|
|
: data(_data)
|
|
, refcounter((std::atomic_int*)owner.allocate(sizeof(std::atomic_int)))
|
|
, owner(_owner)
|
|
{
|
|
refcounter->store(1);
|
|
}
|
|
|
|
shared_ptr(T* _data, std::atomic_int* refctr, gp::allocator& _owner)
|
|
: data(_data)
|
|
, refcounter(refctr)
|
|
, owner(_owner)
|
|
{
|
|
refcounter->store(1);
|
|
}
|
|
|
|
void dirty_clear() {
|
|
if(!refcounter) return;
|
|
if(refcounter->fetch_sub(1, std::memory_order::acq_rel) == 0) {
|
|
if(data) {
|
|
data->~T();
|
|
owner.deallocate(refcounter);
|
|
owner.deallocate(data);
|
|
}
|
|
}
|
|
}
|
|
public:
|
|
template<typename ...U>
|
|
static shared_ptr make(gp::allocator& owner, U&&... args) {
|
|
auto ptr = owner.allocate(sizeof(T));
|
|
return shared_ptr(new(ptr) T(gp::forward<U>(args)...), owner);
|
|
}
|
|
|
|
template<typename U>
|
|
shared_ptr<U> cast() {
|
|
return shared_ptr<U>(data, refcounter, owner);
|
|
}
|
|
|
|
T* operator->() {
|
|
return data;
|
|
}
|
|
|
|
T& operator*() {
|
|
return *data;
|
|
}
|
|
|
|
operator bool() {
|
|
return data != nullptr;
|
|
}
|
|
|
|
shared_ptr(shared_ptr& oth) {
|
|
oth.refcounter->fetch_add(1, std::memory_order::acquire);
|
|
|
|
data = oth.data;
|
|
refcounter = oth.refcounter;
|
|
owner = oth.owner;
|
|
}
|
|
|
|
shared_ptr(shared_ptr&& oth)
|
|
: data(oth.data)
|
|
, owner(oth.owner)
|
|
{
|
|
oth.data = nullptr;
|
|
oth.refcounter = nullptr;
|
|
}
|
|
|
|
shared_ptr& operator=(shared_ptr& oth) {
|
|
dirty_clear();
|
|
(*oth.refcounter)++;
|
|
|
|
data = oth.data;
|
|
refcounter = oth.refcounter;
|
|
owner = oth.owner;
|
|
}
|
|
|
|
shared_ptr& operator=(shared_ptr&& oth) {
|
|
dirty_clear();
|
|
data = oth.data;
|
|
owner = oth.owner;
|
|
}
|
|
|
|
~shared_ptr() {
|
|
dirty_clear();
|
|
}
|
|
};
|
|
|
|
}
|