libicq2000/libicq2000/ref_ptr.h

   1 // -*- mode: C++ -*-
   2 /*
   3  * ref_ptr. A reference counted template class. Similar to the STL
   4  * auto_ptr, but generalised for reference counting.
   5  *
   6  * Copyright (C) 2002 Barnaby Gray <barnaby@beedesign.co.uk>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  21  *
  22  */
  23
  24 #ifndef REF_PTR_H
  25 #define REF_PTR_H
  26
  27 namespace ICQ2000 {
  28
  29   template <typename Object>
  30   class ref_ptr {
  31    protected:
  32     Object *m_instance;
  33     /* note: the actual reference count is controlled on the object -
  34        it turned out problematic having it stored in the ref_ptr,
  35        for reasons I won't go into here ;-) */
  36
  37    public:
  38     ref_ptr()
  39       : m_instance(NULL)
  40     { }
  41
  42     ref_ptr(const ref_ptr<Object>& that)
  43       : m_instance(that.m_instance)
  44     {
  45       if (m_instance != NULL)
  46         ++(m_instance->count);
  47     }
  48
  49     ref_ptr(Object *o)
  50       : m_instance(o)
  51     {
  52       if (m_instance != NULL)
  53         ++(m_instance->count);
  54       /* zeroed inside Contact now */
  55     }
  56
  57     ~ref_ptr()
  58     {
  59       if (m_instance != NULL && --(m_instance->count) == 0)
  60         delete m_instance;
  61     }
  62
  63     Object* get()
  64     {
  65       return m_instance;
  66     }
  67
  68     const Object* get() const
  69     {
  70       return m_instance;
  71     }
  72
  73     Object* operator->()
  74     {
  75       return m_instance;
  76     }
  77
  78     const Object* operator->() const
  79     {
  80       return m_instance;
  81     }
  82
  83     Object& operator*()
  84     {
  85       return *m_instance;
  86     }
  87
  88     const Object& operator*() const
  89     {
  90       return *m_instance;
  91     }
  92
  93     // for debugging
  94     unsigned int count() const
  95     {
  96       return m_instance->count;
  97     }
  98
  99     ref_ptr& operator=(const ref_ptr<Object>& that) {
 100       if (m_instance != NULL && --(m_instance->count) == 0) {
 101         delete m_instance;
 102       }
 103       m_instance = that.m_instance;
 104       if (m_instance != NULL)
 105         ++(m_instance->count);
 106       return *this;
 107     }
 108
 109   };
 110
 111 }
 112
 113 #endif