#ifndef GLTB_REFPTR_H_
#define GLTB_REFPTR_H_

#include <type_traits>

namespace gltb {
	/**
	 * A template class wrapping a pointer to a reference counted
	 * object that transparently performs the required reference
	 * counting for it.
	 *
	 * Implementation note: this class takes ReferencedObject and
	 * ThreadSafeReferencedObject as arguments. Therefore these
	 * classes must stay in sync.
	 */
	template<class objectType>
	class RefPtr {
		public:
			RefPtr()
			{
				this->object=0;
			}

			RefPtr(objectType *object)
			{
				this->object=object;
				if(object!=0) {
					object->increaseReferenceCount();
				}
			};

			RefPtr(RefPtr<objectType> const &ptr)
			{
				object=ptr.object;
				if(object!=0) {
					object->increaseReferenceCount();
				}
			}

			template<class objectType2>
			RefPtr(RefPtr<objectType2> const &ptr, typename std::enable_if<std::is_base_of<objectType, objectType2>::value, int>::type dummy = 0)
			{
				object = ptr.getNakedPointer();
				if(object != 0) {
					object->increaseReferenceCount();
				}
			}

			/// move constructor that steals reference from other RefPtr
			RefPtr(RefPtr<objectType> &&ptr)
			{
				object=ptr.object;
				ptr.object=0;
			}

#if 0  // RefPtr<objectType2> is a completely different type; its object pointer is inaccessible
			/// move constructor that steals reference from other RefPtr
			template<class objectType2>
			RefPtr(RefPtr<objectType2> &&ptr)
			{
				object = static_cast<objectType *>(ptr.object);
				ptr.object = 0;
			}
#endif

			~RefPtr()
			{
				if(object!=0) {
					object->decreaseReferenceCount();
				}
			};

			objectType *operator -> ()
			{
				return object;
			}

			const objectType *operator -> () const
			{
				return object;
			}

			RefPtr<objectType> &operator =(RefPtr<objectType> const &refPtr)
			{
				if(object!=0) {
					object->decreaseReferenceCount();
				}
				object=refPtr.object;
				if(object!=0) {
					object->increaseReferenceCount();
				}
				return *this;
			}

			RefPtr<objectType> &operator =(RefPtr<objectType> &&refPtr)
			{
				if(object!=0) {
					object->decreaseReferenceCount();
				}
				object=refPtr.object;
				refPtr.object=0;
				return *this;
			}

			objectType *getNakedPointer() const
			{
				return object;
			}

		private:
			objectType *object;
	};

	template<class objectType>
	bool operator == (const RefPtr<objectType> &reference, void *pointer) {
		return (reference.getNakedPointer()==pointer);
	}

	template<class objectType1, class objectType2>
	bool operator == (const RefPtr<objectType1> &reference1, const RefPtr<objectType2> &reference2) {
		return (reference1.getNakedPointer()==reference2.getNakedPointer());
	}

	template<class objectType>
	bool operator != (const RefPtr<objectType> &reference, void *pointer) {
		return (reference.getNakedPointer()!=pointer);
	}

	template<class objectType1, class objectType2>
	bool operator != (const RefPtr<objectType1> &reference1, const RefPtr<objectType2> &reference2) {
		return (reference1.getNakedPointer()!=reference2.getNakedPointer());
	}

	template<class objectType>
	bool operator < (const RefPtr<objectType> &reference1, const RefPtr<objectType> &reference2) {
		return reference1.getNakedPointer()<reference2.getNakedPointer();
	}
}

#endif /*REFPTR_H_*/