juce/source/src/memory/juce_OptionalScopedPointer.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifndef __JUCE_OPTIONALSCOPEDPOINTER_JUCEHEADER__
  27 #define __JUCE_OPTIONALSCOPEDPOINTER_JUCEHEADER__
  28
  29 #include "juce_ScopedPointer.h"
  30
  31
  32 //==============================================================================
  33 /**
  34     Holds a pointer to an object which can optionally be deleted when this pointer
  35     goes out of scope.
  36
  37     This acts in many ways like a ScopedPointer, but allows you to specify whether or
  38     not the object is deleted.
  39
  40     @see ScopedPointer
  41 */
  42 template <class ObjectType>
  43 class OptionalScopedPointer
  44 {
  45 public:
  46     //==============================================================================
  47     /** Creates an empty OptionalScopedPointer. */
  48     OptionalScopedPointer() : shouldDelete (false) {}
  49
  50     /** Creates an OptionalScopedPointer to point to a given object, and specifying whether
  51         the OptionalScopedPointer will delete it.
  52
  53         If takeOwnership is true, then the OptionalScopedPointer will act like a ScopedPointer,
  54         deleting the object when it is itself deleted. If this parameter is false, then the
  55         OptionalScopedPointer just holds a normal pointer to the object, and won't delete it.
  56     */
  57     OptionalScopedPointer (ObjectType* objectToHold, bool takeOwnership)
  58         : object (objectToHold), shouldDelete (takeOwnership)
  59     {
  60     }
  61
  62     /** Takes ownership of the object that another OptionalScopedPointer holds.
  63
  64         Like a normal ScopedPointer, the objectToTransferFrom object will become null,
  65         as ownership of the managed object is transferred to this object.
  66
  67         The flag to indicate whether or not to delete the managed object is also
  68         copied from the source object.
  69     */
  70     OptionalScopedPointer (OptionalScopedPointer& objectToTransferFrom)
  71         : object (objectToTransferFrom.release()),
  72           shouldDelete (objectToTransferFrom.shouldDelete)
  73     {
  74     }
  75
  76     /** Takes ownership of the object that another OptionalScopedPointer holds.
  77
  78         Like a normal ScopedPointer, the objectToTransferFrom object will become null,
  79         as ownership of the managed object is transferred to this object.
  80
  81         The ownership flag that says whether or not to delete the managed object is also
  82         copied from the source object.
  83     */
  84     OptionalScopedPointer& operator= (OptionalScopedPointer& objectToTransferFrom)
  85     {
  86         if (object != objectToTransferFrom.object)
  87         {
  88             clear();
  89             object = objectToTransferFrom.object;
  90         }
  91
  92         shouldDelete = objectToTransferFrom.shouldDelete;
  93         return *this;
  94     }
  95
  96     /** The destructor may or may not delete the object that is being held, depending on the
  97         takeOwnership flag that was specified when the object was first passed into an
  98         OptionalScopedPointer constructor.
  99     */
 100     ~OptionalScopedPointer()
 101     {
 102         clear();
 103     }
 104
 105     //==============================================================================
 106     /** Returns the object that this pointer is managing. */
 107     inline operator ObjectType*() const noexcept                    { return object; }
 108
 109     /** Returns the object that this pointer is managing. */
 110     inline ObjectType& operator*() const noexcept                   { return *object; }
 111
 112     /** Lets you access methods and properties of the object that this pointer is holding. */
 113     inline ObjectType* operator->() const noexcept                  { return object; }
 114
 115     //==============================================================================
 116     /** Removes the current object from this OptionalScopedPointer without deleting it.
 117         This will return the current object, and set this OptionalScopedPointer to a null pointer.
 118     */
 119     ObjectType* release() noexcept                                  { return object.release(); }
 120
 121     /** Resets this pointer to null, possibly deleting the object that it holds, if it has
 122         ownership of it.
 123     */
 124     void clear()
 125     {
 126         if (! shouldDelete)
 127             object.release();
 128     }
 129
 130     //==============================================================================
 131     /** Swaps this object with another OptionalScopedPointer.
 132         The two objects simply exchange their states.
 133     */
 134     void swapWith (OptionalScopedPointer<ObjectType>& other) noexcept
 135     {
 136         object.swapWith (other.object);
 137         std::swap (shouldDelete, other.shouldDelete);
 138     }
 139
 140 private:
 141     //==============================================================================
 142     ScopedPointer<ObjectType> object;
 143     bool shouldDelete;
 144 };
 145
 146
 147 #endif   // __JUCE_OPTIONALSCOPEDPOINTER_JUCEHEADER__