aref.hh

2007年机器人足球世界杯3D仿真组亚军

/*
 *  Little Green BATS (2006)
 *
 *  Authors: 	Martin Klomp ([e-mail])
 *		Mart van de Sanden ([e-mail])
 *		Sander van Dijk ([e-mail])
 *		A. Bram Neijt ([e-mail])
 *		Matthijs Platje ([e-mail])
 *
 *  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_