gplib/include/gp/pointers.hpp

#pragma once

#include "gp/algorithm/modifiers.hpp"
#include "gp/algorithm/move.hpp"
#include "gp/buffer.hpp"
#include "gp/function.hpp"



template<typename T>
class unique_ptr {
	T* data;
	gp::allocator const& owner;

	unique_ptr(T* _data, gp::allocator const& _owner)
	: data(data)
	, owner(_owner)
	{}

	void dirty_clear() {
		if(data) {
			data->~T();
			owner.deallocate(data);
		}
	}
public:
	template<typename ...U>
	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);
	}

	T& operator->() {
		return *data;
	}

	T& operator*() {
		return *data;
	}

	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 const& owner;

	shared_ptr(T* _data, gp::allocator const& _owner)
	: data(data)
	, owner(_owner)
	{}

	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>
	shared_ptr make(gp::allocator& owner, U&&... args) {
		auto ptr = owner.allocate(sizeof(T));
		auto shared_atomic = owner.allocate(sizeof(std::atomic_int));
		refcounter = new(shared_atomic) std::atomic_int();
		refcounter->store(1);
		return shared_ptr(new(ptr) T(gp::forward<U>(args)...), owner);
	}

	T& operator->() {
		return *data;
	}

	T& operator*() {
		return *data;
	}

	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();
	}
};