memory.hpp

#ifndef _MEMORY_HPP__
#define _MEMORY_HPP__

namespace std {

template <typename T, typename Enable = void>
class cow_shared_ptr;

class cow_shared_ptr_base {
public:
	cow_shared_ptr_base() : m_UseCount(0) {}

private:
	int m_UseCount;

	template<typename T, typename Enable> friend class cow_shared_ptr;
};

template<class T>
class cow_shared_ptr<T, typename std::enable_if< std::is_base_of<cow_shared_ptr_base, T>::value >::type> {
public:
	cow_shared_ptr ( ) {
		attach ( NULL );
	}

	cow_shared_ptr ( T * data ) {
		if(data) data->m_UseCount = 0;
		attach ( data );
	}

	cow_shared_ptr ( const cow_shared_ptr<T> & other ) {
		attach ( other.m_Data );
	}

	cow_shared_ptr ( cow_shared_ptr<T> && other ) noexcept {
		m_Data = other.m_Data;
		other.m_Data = NULL;
	}

	~cow_shared_ptr ( ) noexcept {
		detach ( );
	}

	cow_shared_ptr<T> & operator = ( const cow_shared_ptr<T> & other ) {
		if(this == &other) return *this;

		detach ( );
		attach ( other.m_Data );

		return *this;
	}

	cow_shared_ptr<T> & operator = ( cow_shared_ptr<T> && other ) noexcept {
		swap(*this, other);
		return *this;
	}

	T * operator -> ( ) {
		make_unique( );
		return m_Data;
	}

	T const * operator -> ( ) const {
		return m_Data;
	}

	T & operator * ( ) {
		make_unique( );
		return *m_Data;
	}

	T const & operator * ( ) const {
		return *m_Data;
	}

	T * get () {
		make_unique( );
		return m_Data;
	}

	T const * get () const {
		return m_Data;
	}

	bool unique ( ) const {
		return m_Data == NULL || m_Data->m_UseCount == 1;
	}

	int getUseCount() const {
		if(m_Data == NULL) return 0;
		return m_Data->m_UseCount;
	}

private:
	void attach ( T * data ) {
		m_Data = data;
		if(m_Data) m_Data->m_UseCount++;
	}

	void detach ( ) {
		if(m_Data && --(m_Data->m_UseCount) <= 0) delete m_Data;
		m_Data = NULL;
	}

	void make_unique( ) {
		if(unique( )) return;

		T* tmp = m_Data;
		detach( );
		tmp = std::clone(tmp);
		tmp->m_UseCount = 0;
		attach(tmp);
	}

	T* m_Data;

	friend void swap ( cow_shared_ptr<T> & first, cow_shared_ptr<T> & second ) {
		T* tmp = first.m_Data;
		first.m_Data = second.m_Data;
		second.m_Data = tmp;
	}
};

template<class T>
class cow_shared_ptr<T, typename std::enable_if< ! std::is_base_of<cow_shared_ptr_base, T>::value >::type> {
	struct cow_shared_ptr_data {
		T * m_Data;
		int m_UseCount;
		cow_shared_ptr_data ( T * data ) : m_Data ( data ), m_UseCount( 0 ) { }
		~cow_shared_ptr_data ( ) {
			delete m_Data;
		}
	};

public:
	cow_shared_ptr ( ) {
		attach ( NULL );
	}

	cow_shared_ptr ( T * data ) {
		attach ( new cow_shared_ptr_data( data ) );
	}

	cow_shared_ptr ( const cow_shared_ptr<T> & other ) {
		attach ( other.m_Data );
	}

	cow_shared_ptr ( cow_shared_ptr<T> && other ) noexcept {
		m_Data = other.m_Data;
		other.m_Data = NULL;
	}

	~cow_shared_ptr ( ) noexcept {
		detach ( );
	}

	cow_shared_ptr<T> & operator = ( const cow_shared_ptr<T> & other ) {
		if(this == &other) return *this;

		detach ( );
		attach ( other.m_Data );

		return *this;
	}

	cow_shared_ptr<T> & operator = ( cow_shared_ptr<T> && other ) noexcept {
		swap(*this, other);
		return *this;
	}

	T * operator -> ( ) {
		make_unique( );
		return m_Data->m_Data;
	}

	T const * operator -> ( ) const {
		return m_Data->m_Data;
	}

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

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

	T * get () {
		make_unique( );
		return m_Data->m_Data;
	}

	T const * get () const {
		return m_Data->m_Data;
	}

	bool unique ( ) const {
		return m_Data == NULL || m_Data->m_UseCount == 1;
	}

private:
	void attach ( typename cow_shared_ptr<T>::cow_shared_ptr_data * data ) {
		m_Data = data;
		if(m_Data) m_Data->m_UseCount++;
	}

	void detach ( ) {
		if(m_Data && --(m_Data->m_UseCount) <= 0) delete m_Data;
		m_Data = NULL;
	}

	void make_unique( ) {
		if(unique( )) return;

		typename cow_shared_ptr<T>::cow_shared_ptr_data* tmp = m_Data;
		detach( );
		attach(new cow_shared_ptr_data(std::clone(tmp->m_Data)));
	}

	cow_shared_ptr_data * m_Data;

	friend void swap ( cow_shared_ptr<T> & first, cow_shared_ptr<T> & second ) {
		typename cow_shared_ptr<T>::cow_shared_ptr_data* tmp = first.m_Data;
		first.m_Data = second.m_Data;
		second.m_Data = tmp;
	}
};

template<class T>
const cow_shared_ptr<T>& make_const(cow_shared_ptr<T>& ptr) {
	return static_cast<const cow_shared_ptr<T>&>(ptr);
}

template<class T>
const cow_shared_ptr<T>& make_const(const cow_shared_ptr<T>& ptr) {
	return ptr;
}

} /* namespace std */

#endif // _MEMORY_HPP__