1// vim:set ft=cpp: -*- Mode: C++ -*-
2/*
3 * (c) 2008-2009 Alexander Warg <warg@os.inf.tu-dresden.de>
4 *     economic rights: Technische Universität Dresden (Germany)
5 *
6 * This file is part of TUD:OS and distributed under the terms of the
7 * GNU General Public License 2.
8 * Please see the COPYING-GPL-2 file for details.
9 *
10 * As a special exception, you may use this file as part of a free software
11 * library without restriction.  Specifically, if other files instantiate
12 * templates or use macros or inline functions from this file, or you compile
13 * this file and link it with other files to produce an executable, this
14 * file does not by itself cause the resulting executable to be covered by
15 * the GNU General Public License.  This exception does not however
16 * invalidate any other reasons why the executable file might be covered by
17 * the GNU General Public License.
18 */
19
20#pragma once
21
22namespace cxx {
23
24/**
25 * \ingroup cxx_api
26 * \brief Smart pointer with automatic deletion.
27 * \tparam T The type of the referenced object.
28 *
29 * This smart pointer calls the delete operator when the destructor
30 * is called. This has the effect that the object the pointer points to
31 * will be deleted when the pointer goes out of scope, or a new value gets
32 * assigned. The smart pointer provides a release() method to get a normal
33 * pointer to the object and set the smart pointer to NULL.
34 */
35template< typename T>
36class Auto_ptr
37{
38private:
39  T *_p;
40
41  struct Priv_type;
42
43public:
44  /** \brief The referenced type. */
45  typedef T Ref_type;
46
47  /**
48   * \brief Construction by assignment of a normal pointer.
49   * \param p The pointer to the object
50   */
51  explicit Auto_ptr(T *p = 0) throw() : _p(p) {}
52
53  /**
54   * \brief Copy construction, releases the original pointer.
55   * \param o The smart pointer, which shall be copied and released.
56   */
57  Auto_ptr(Auto_ptr const &o) throw()
58  : _p(const_cast<Auto_ptr<T>&>(o).release())
59  {}
60
61  /**
62   * \brief Assignment from another smart pointer.
63   * \param o The source for the assignment (will be released).
64   */
65  Auto_ptr &operator = (Auto_ptr const &o) throw()
66  {
67    if (&o != this)
68      {
69	if (_p) delete _p;
70	_p = const_cast<Auto_ptr<T>&>(o).release();
71      }
72    return *this;
73  }
74
75  /** \brief Destruction, shall delete the object. */
76  ~Auto_ptr() throw()
77  { if (_p) delete _p; }
78
79  /** \brief Dereference the pointer. */
80  T &operator * () const throw() { return *_p; }
81
82  /** \brief Member access for the object. */
83  T *operator -> () const throw() { return _p; }
84
85  /**
86   * \brief Get the normal pointer.
87   * \attention This function will not release the object, the
88   *            object will be deleted by the smart pointer.
89   */
90  T *get() const throw() { return _p; }
91
92  /**
93   * \brief Release the object and get the normal pointer back.
94   *
95   * After calling this function the smart pointer will point to NULL
96   * and the object will not be deleted by the pointer anymore.
97   */
98  T *release() throw() { T *t = _p; _p = 0; return t; }
99
100  /**
101   * \brief Delete the object and reset the smart pointer to NULL.
102   */
103  void reset(T *p = 0) throw()
104  {
105    if (_p) delete _p;
106    _p = p;
107  }
108
109  /** \brief Operator for `if (!ptr) ...`. */
110  operator Priv_type * () const throw()
111  { return reinterpret_cast<Priv_type*>(_p); }
112};
113}
114