gplib/include/gp/utils/pointers.hpp

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

}