reference.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_REFERENCE_HPP_INCLUDED
#define _STRUS_REFERENCE_HPP_INCLUDED
#include <cstdlib>
#include <stdexcept>
#include <new>

namespace strus
{

template <class Object>
class Reference
{
public:
        Reference()
                :m_obj(0),m_refcnt(0){}
        Reference( Object* obj_, bool doThrow=true)
                :m_obj(0),m_refcnt(0)
        {
                if (obj_) try
                {
                        m_refcnt = newRefCnt();
                        m_obj = obj_;
                }
                catch (const std::bad_alloc&)
                {
                        delete obj_;
                        if (doThrow) throw std::bad_alloc();
                }
        }
        Reference( const Reference& o)
                :m_obj(o.m_obj),m_refcnt(o.m_refcnt)
        {
                if (m_refcnt) ++*m_refcnt;
        }

        ~Reference()
        {
                freeRef();
        }

        Reference& operator = (const Reference& o)
        {
                m_obj = o.m_obj;
                m_refcnt = o.m_refcnt;
                if (m_refcnt) ++*m_refcnt;
                return *this;
        }

        void reset( Object* obj_=0)
        {
                if (!m_refcnt)
                {
                        if (obj_)
                        {
                                try
                                {
                                        m_refcnt = newRefCnt();
                                }
                                catch (const std::bad_alloc&)
                                {
                                        delete obj_;
                                        return;
                                }
                        }
                }
                else if (*m_refcnt == 1)
                {
                        delete m_obj;
                }
                else if (obj_)
                {
                        int* rc = newRefCnt();
                        freeRef();
                        m_refcnt = rc;
                }
                else
                {
                        freeRef();
                        m_refcnt = 0;
                }
                m_obj = obj_;
        }

        Object* operator->()                            {return m_obj;}
        const Object* operator->() const                {return m_obj;}
        Object& operator*()                             {return *m_obj;}
        const Object& operator*() const                 {return *m_obj;}

        const Object* get() const                       {return m_obj;}
        Object* get()                                   {return m_obj;}

        Object* release()
        {
                if (m_refcnt && *m_refcnt == 1)
                {
                        --*m_refcnt;
                        Object* rt = m_obj;
                        std::free( m_refcnt);
                        m_refcnt = 0;
                        m_obj = 0;
                        return rt;
                }
                else if (m_refcnt)
                {
                        throw std::logic_error( "cannot release shared object (having more than one reference)");
                }
                else
                {
                        return 0;
                }
        }

        unsigned int refcnt() const
        {
                return m_refcnt?(*m_refcnt):0;
        }

private:
        int* newRefCnt()
        {
                int* rt = (int*)std::malloc(sizeof(int));
                if (!rt) throw std::bad_alloc();
                *rt = 1;
                return rt;
        }
        void freeRef()
        {
                if (m_refcnt && --*m_refcnt == 0)
                {
                        delete m_obj;
                        std::free( m_refcnt);
                        m_refcnt = 0;
                        m_obj = 0;
                }
        }

private:
        Object* m_obj;
        mutable int* m_refcnt;
};

}
#endif