src/3rdparty/v8/src/smart-array-pointer.h

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #ifndef V8_SMART_ARRAY_POINTER_H_
  29 #define V8_SMART_ARRAY_POINTER_H_
  30
  31 namespace v8 {
  32 namespace internal {
  33
  34
  35 // A 'scoped array pointer' that calls DeleteArray on its pointer when the
  36 // destructor is called.
  37 template<typename T>
  38 class SmartArrayPointer {
  39  public:
  40   // Default constructor. Constructs an empty scoped pointer.
  41   inline SmartArrayPointer() : p_(NULL) {}
  42
  43   // Constructs a scoped pointer from a plain one.
  44   explicit inline SmartArrayPointer(T* ptr) : p_(ptr) {}
  45
  46   // Copy constructor removes the pointer from the original to avoid double
  47   // freeing.
  48   inline SmartArrayPointer(const SmartArrayPointer<T>& rhs) : p_(rhs.p_) {
  49     const_cast<SmartArrayPointer<T>&>(rhs).p_ = NULL;
  50   }
  51
  52   // When the destructor of the scoped pointer is executed the plain pointer
  53   // is deleted using DeleteArray.  This implies that you must allocate with
  54   // NewArray.
  55   inline ~SmartArrayPointer() { if (p_) DeleteArray(p_); }
  56
  57   inline T* operator->() const { return p_; }
  58
  59   // You can get the underlying pointer out with the * operator.
  60   inline T* operator*() { return p_; }
  61
  62   // You can use [n] to index as if it was a plain pointer
  63   inline T& operator[](size_t i) {
  64     return p_[i];
  65   }
  66
  67   // We don't have implicit conversion to a T* since that hinders migration:
  68   // You would not be able to change a method from returning a T* to
  69   // returning an SmartArrayPointer<T> and then get errors wherever it is used.
  70
  71
  72   // If you want to take out the plain pointer and don't want it automatically
  73   // deleted then call Detach().  Afterwards, the smart pointer is empty
  74   // (NULL).
  75   inline T* Detach() {
  76     T* temp = p_;
  77     p_ = NULL;
  78     return temp;
  79   }
  80
  81   // Assignment requires an empty (NULL) SmartArrayPointer as the receiver. Like
  82   // the copy constructor it removes the pointer in the original to avoid
  83   // double freeing.
  84   inline SmartArrayPointer& operator=(const SmartArrayPointer<T>& rhs) {
  85     ASSERT(is_empty());
  86     T* tmp = rhs.p_;  // swap to handle self-assignment
  87     const_cast<SmartArrayPointer<T>&>(rhs).p_ = NULL;
  88     p_ = tmp;
  89     return *this;
  90   }
  91
  92   inline bool is_empty() { return p_ == NULL; }
  93
  94  private:
  95   T* p_;
  96 };
  97
  98 } }  // namespace v8::internal
  99
 100 #endif  // V8_SMART_ARRAY_POINTER_H_