/ray/src/lib/tl/refnode.h

Go to the documentation of this file.

/*
 * lib/tl/refnode.h 
 * 
 * Reference counting node and base class for derivation of internally 
 * used unique class. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _TemplateLibrary_RefNode_H_
#define _TemplateLibrary_RefNode_H_ 1

#include <lib/sconfig.h>    /* MUST be first */

#include <lib/threads/atomic.h>


// As defined further down. 
template<typename T,typename NSPC>class RefNode;



class _packed_ InternalRefNodeBase
{
    template<typename T,typename NSPC>friend class RefNode;
    private:
        int refcnt;
        
    protected:
        inline void _InternalRefNodeBase_aqref()
            {  ++refcnt;  }
        inline void _InternalRefNodeBase_deref()
            {  if(--refcnt<=0)  delete this;  }
        
    private:
        void _failCritAssert();
        
        InternalRefNodeBase(const InternalRefNodeBase &);
        InternalRefNodeBase &operator=(const InternalRefNodeBase &);
    public:
        inline InternalRefNodeBase() : refcnt(0)  { }
        inline virtual ~InternalRefNodeBase()  {  if(refcnt) _failCritAssert();  }
};


class _packed_ InternalRefNodeBase_ThreadSave
{
    template<typename T,typename NSPC>friend class RefNode;
    private:
        AtomicInt refcnt;
        
    protected:
        inline void _InternalRefNodeBase_aqref()
            {  refcnt.inc();  }
        inline void _InternalRefNodeBase_deref()
            {  if(refcnt.DecAndTest()) delete this;  }
        
    private:
        void _failCritAssert();
        
        InternalRefNodeBase_ThreadSave(const InternalRefNodeBase_ThreadSave &);
        InternalRefNodeBase_ThreadSave &operator=(const InternalRefNodeBase_ThreadSave &);
    public:
        inline InternalRefNodeBase_ThreadSave() : refcnt(0)  { }
        inline virtual ~InternalRefNodeBase_ThreadSave()
            {  if(refcnt.val()) _failCritAssert();  }
};


struct _packed_ _RefNode_VoidNSPC
{
    inline _RefNode_VoidNSPC(){}
    inline ~_RefNode_VoidNSPC(){}
};


template<typename T,typename NSPC=_RefNode_VoidNSPC>
    class _packed_ RefNode : public NSPC
{
    private:
        T *in;   // internal node
        
        inline void _aqref()  {  if(in) in->_InternalRefNodeBase_aqref();  }
        inline void _deref()  {  if(in) in->_InternalRefNodeBase_deref();  }
    public:
        inline RefNode() : NSPC()  {  in=NULL;  }
        inline RefNode(const RefNode &r) : NSPC()  {  in=r.in;  _aqref();  }
        inline ~RefNode()  {  _deref();  /*in=NULL;*/  }
        
        inline RefNode &operator=(const RefNode &r)
            {  _deref();  in=r.in;  _aqref();  return(*this);  }
        
        inline void deref()  {  _deref();  }
        
        inline bool operator!() const  {  return(!in);  }
        inline operator bool() const  {  return((bool)in);  }
        
        inline RefNode(T *_in)  {  in=_in;  _aqref();  }
        inline RefNode &operator=(T *_in)
            {  _deref();  in=_in;  _aqref();  return(*this);  }
        
        inline T *operator->()  {  return(in);  }
        inline const T*operator->() const  {  return(in);  }
        
        inline T &operator*()  {  return(*in);  }
        inline const T &operator*() const  {  return(*in);  }
};

#endif /* _TemplateLibrary_RefNode_H_ */

---