/* *  Little Green BATS (2006) * *  Authors: 	Martin Klomp (martin@ai.rug.nl) *		Mart van de Sanden (vdsanden@ai.rug.nl) *		Sander van Dijk (sgdijk@ai.rug.nl) *		A. Bram Neijt (bneijt@gmail.com) *		Matthijs Platje (mplatje@gmail.com) * *  Date: 	September 14, 2006 * *  Website:	http://www.littlegreenbats.nl * *  Comment:	Please feel free to contact us if you have any  *		problems or questions about the code. * * *  License: 	This program is free software; you can redistribute  *		it and/or modify it under the terms of the GNU General *		Public License as published by the Free Software  *		Foundation; either version 2 of the License, or (at  *		your option) any later version. * *   		This program is distributed in the hope that it will *		be useful, but WITHOUT ANY WARRANTY; without even the *		implied warranty of MERCHANTABILITY or FITNESS FOR A *		PARTICULAR PURPOSE.  See the GNU General Public *		License for more details. * *   		You should have received a copy of the GNU General *		Public License along with this program; if not, write *		to the Free Software Foundation, Inc., 59 Temple Place -  *		Suite 330, Boston, MA  02111-1307, USA. * */#ifndef __INC_BATS_AREF_HH_#define __INC_BATS_AREF_HH_#include <iostream>namespace bats {  /** \brief Reference counting template   *   *  This is an automatic reference class template. It uses   *  reference counting to automaticaly destroy the   *  encpasuled class when all references go out of   *  scope.   *   *  An aref-ed class should always be initialized with a new (aref<Foo> x = new Foo(..);)   *  or by assigning another aref to it. You should <b>never</b> assign the address of   *  an object to it (never do this: aref<Foo> = \&foo; never! ... No really, don't do it! ... Uh! ...).   *   *   */  template <class _T>  class aref {  public:    _T *obj;  private:    //    template <class O>    void copy(aref<_T> const &_other)    {      obj = _other.obj;      if (obj)        obj->incRef();    }    void destroy()    {      if (obj && !obj->decRef())              delete obj;    }  public:    aref()      : obj(0) {}    /*    aref(_T const &_obj)    //: obj(new _T(_obj))    {      obj = new _T(_obj);      obj->incRef();      }*/    aref(_T *_obj)      : obj(_obj)    {      if (obj)        obj->incRef();    }    ~aref() { destroy(); }    aref(aref<_T> const &_other) { copy(_other); }    aref<_T> &operator=(aref<_T> const &_other)    {      if (this != &_other) {        destroy();        copy(_other);      }      return *this;    }    /**     *  Compares the encapsulated object, not the reference number!     */    bool operator<(aref<_T> const &other) const { return *obj < *other.obj; }    /**     *  @returns false when we encapsulate a zero pointer (when the reference is empty).     */    operator bool() const { return obj; }    /**     *  Makes it posible to use the methos of Bla in aref<Bla>.     *     */    _T *operator->() const { return obj; }    _T &operator*() const { return *obj; }    /**     *  Depricated! I'm not sure who made this, but the dereference operator should     *  be used for this!     */    _T* operator()() const { return obj; }  };  /**   *  The aref_cast. Use this to do a static cast from aref<Foo> to aref<Bar>. Which   *  only makes sense when one of them enherits from the other.   */  template <class U, class T>  aref<U> aref_cast(aref<T> const &other)  {    return aref<U>(static_cast<U*>(other.obj));  }};#endif // __INC_BATS_AREF_HH_