source: liblaziness/r.h @ 4

#ifndef __R_H__
#define __R_H__
#include <exception>
#include "primitive.h"
#include "assert.h"
#include <type_traits>
#include <unordered_map>

class NullReference : public std::exception
{
        public:
                virtual const char* what() const throw() override { return "Trying to use null reference"; }
};

/*
 * Ahhoz hogy önhívatkozás működjön egyelőre egy hash_map-et
 * használjuk, későbbiékben majd vmi jobb megoldás, mert nagyon nem
 * teccik ez :)
 */
/*class RBase
{
        public:
                typedef std::unordered_map<const void*, long> map;
                inline RBase()
                {
                }
                inline void init()
                {
                        instances.insert(map::value_type(ptr(), 0));
                }
                virtual ~RBase()
                {
                        instances.erase(ptr());
                }
                inline bool isInitialized() const
                {
                        return instances.end() != instances.find(ptr());
                };
        private:
                inline map::key_type ptr() const
                {
                        return static_cast<map::key_type>(this);
                };
                static map instances;
};

RBase::map RBase::instances;*/

template <typename T, bool overridden = true>
class R //: public RBase
{
        public: // TODO: make protected
                struct VS // Value Structure
                {
                        Int c;
                        T* pVal;
                        VS(Int c) : c(c) { }
                };

        protected:
                /*R<T>* stub;
                inline bool isStub()
                {

                }*/
                // ctor
                explicit R(int i) : vs(new VS(1))
                {
                        // init();
                }
                // ctor (lvalue)
                template<typename U, bool od>
                R(R<U, od>& o, int i)
                {
                        vs = reinterpret_cast<R<T, overridden>::VS*>(o.vs);
                        cinc();
                }
                // ctor (rvalue)
                template<typename U, bool od>
                R(R<U, od>&& o, int i)
                {
                        vs = reinterpret_cast<R<T, overridden>::VS*>(o.vs);
                        cinc();
                }

        public:
                // element type
                typedef T etype;
                // def ctor
                R() : vs(nullptr)
                {
                        // init();
                }
                // ctor
                template<typename U, bool od> R(R<U, od>& o)
                {
                        _assert_subclass<U, T> ERROR;
                        vs = reinterpret_cast<R<T, overridden>::VS*>(o.vs);
                        cinc();
                }
                template<typename U, bool od> R(R<U, od>&& o)
                {
                        _assert_subclass<U, T> ERROR;
                        vs = reinterpret_cast<R<T, overridden>::VS*>(o.vs);
                        cinc();
                }
                // dtor
                virtual ~R()
                {
                        free();
                }
                template<typename U, bool od>
                R<T, od>& operator=(R<U, od>&& o)
                {
                        _assert_subclass<U, T> ERROR;
                        return copy(o);
                }
                template<typename U, bool od>
                R<T, od>& operator=(R<U, od>& o)
                {
                        _assert_subclass<U, T> ERROR;
                        return copy(o);
                }
        protected:
                template<typename U, bool od>
                inline R<T, od>& copy(R<U, od>& o)
                {
                        // forceInit();
                        if ((void*)&o != (void*)this)
                        {
                                free();
                                vs = reinterpret_cast<R<T, overridden>::VS*>(o.vs);
                                cinc();
                        }
                        return *reinterpret_cast< R<T, od>* >(this);
                }
                template<typename U, bool od>
                inline R<T, od>& copy(R<U, od>&& o)
                {
                        // forceInit();
                        if ((void*)&o != (void*)this)
                        {
                                free();
                                vs = reinterpret_cast<R<T, overridden>::VS*>(o.vs);
                                cinc();
                        }
                        return *reinterpret_cast< R<T, od>* >(this);
                }
        public:
                // freeing
                void free()
                {
                        if (/*isInitialized() && */cdec() == 0) // TODO: Implement structural cycle freeing
                        {
                                delete vs->pVal;
                                delete vs;
                        }
                        vs = nullptr;
                }
                // dereferencing
                inline T& deref()
                {
                        ensure();
                        return *vs->pVal;
                }
                inline Int refCount() const
                {
                        ensure();
                        return vs->c;
                }
                bool isNull() const
                {
                        return vs == nullptr;
                }

                /*friend R<Int> mkR(Int i);
                template<typename U> friend R<U> mkR();
                template<typename U, typename UFirst> friend R<U> mkR(UFirst first);
                template<typename U, typename UFirst, typename USecond> friend R<U> mkR(UFirst first, USecond second);
                template<typename U, typename UFirst, typename USecond, typename UThird> friend R<U> mkR(UFirst first, USecond second, UThird third);
                template<typename U, typename UFirst, typename USecond, typename UThird, typename UFourth>
                friend R<U> mkR(UFirst first, USecond second, UThird third, UFourth fourth);*/
                friend class Ref;

                // operators
                inline T* operator->()
                {
                        return &this->deref();
                }
                inline T& operator *()
                {
                        return this->deref();
                }

        private:
                /*inline void forceInit()
                {
                        if (!isInitialized())
                        {
                                RBase::init();
                                vs = nullptr;
                        }
                }*/
                inline void ensure() const
                {
                        if (vs == nullptr)
                        {
                                throw NullReference();
                        }
                }
                inline Int cinc()
                {
                        if (vs != nullptr)
                        {
                                return ++vs->c;
                        }
                        else
                        {
                                return -1;
                        }
                }
                inline Int cdec()
                {
                        if (vs != nullptr)
                        {
                                return --vs->c;
                        }
                        else
                        {
                                return -1;
                        }
                }
                // private data
        public: // TODO: make private
                VS* vs;

};

class Ref
{
        public:
                template <typename T>
                static R<T> mk()
                {
                        R<T> ref(0);
                        ref.vs->pVal = new T();
                        return ref;
                }

                template <typename T, typename TFirst>
                static R<T> mk(TFirst first)
                {
                        R<T> ref(0);
                        ref.vs->pVal = new T(first);
                        return ref;
                }

                template <typename T, typename TFirst, typename TSecond>
                static R<T> mk(TFirst first, TSecond second)
                {
                        R<T> ref(0);
                        ref.vs->pVal = new T(first, second);
                        return ref;
                }

                template <typename T, typename TFirst, typename TSecond, typename TThird>
                static R<T> mk(TFirst first, TSecond second, TThird third)
                {
                        R<T> ref(0);
                        ref.vs->pVal = new T(first, second, third);
                        return ref;
                }

                template <typename T, typename TFirst, typename TSecond, typename TThird, typename TFourth>
                static R<T> mk(TFirst first, TSecond second, TThird third, TFourth fourth)
                {
                        R<T> ref(0);
                        ref.vs->pVal = new T(first, second, third, fourth);
                        return ref;
                }

                static R<Int> mk(Int i)
                {
                        R<Int> ref(0);
                        ref.vs->pVal = new Int(i);
                        return ref;
                }
};

/**** specialize for base types ****/
template<>
class R<bool, true> : public R<bool, false>
{
        protected:
                inline R(int i) : R<bool, false>(i) { }
        public:
                inline R() : R<bool, false>() { }
                inline R(R<bool, true>&  o) : R<bool, false>(o, 0) { }
                inline R(R<bool, true>&& o) : R<bool, false>(o, 0) { }
                // additional ctor
                inline R(bool val) : R<bool, false>(0) { vs->pVal = new bool(val); }
                R<bool, true>& operator=(R<bool, true>&  o) { R<bool, false>::copy(o); return *this; }
                R<bool, true>& operator=(R<bool, true>&& o) { R<bool, false>::copy(o); return *this; }
                friend class Ref;
};

#endif