General Purpose library for Freestanding C++ and POSIX systems
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

168 lines
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>(safe, 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();
}
};
}