heap/Strong.h

   1 /*
   2  * Copyright (C) 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef Strong_h
  27 #define Strong_h
  28
  29 #include "Assertions.h"
  30 #include "Handle.h"
  31 #include "HandleHeap.h"
  32
  33 namespace JSC {
  34
  35 class JSGlobalData;
  36 HandleSlot allocateGlobalHandle(JSGlobalData&);
  37
  38 // A strongly referenced handle that prevents the object it points to from being garbage collected.
  39 template <typename T> class Strong : public Handle<T> {
  40     using Handle<T>::slot;
  41     using Handle<T>::setSlot;
  42
  43 public:
  44     typedef typename Handle<T>::ExternalType ExternalType;
  45
  46     Strong()
  47         : Handle<T>()
  48     {
  49     }
  50
  51     Strong(JSGlobalData& globalData, ExternalType value = ExternalType())
  52         : Handle<T>(allocateGlobalHandle(globalData))
  53     {
  54         set(value);
  55     }
  56
  57     Strong(JSGlobalData& globalData, Handle<T> handle)
  58         : Handle<T>(allocateGlobalHandle(globalData))
  59     {
  60         set(handle.get());
  61     }
  62
  63     Strong(const Strong& other)
  64         : Handle<T>()
  65     {
  66         if (!other.slot())
  67             return;
  68         setSlot(HandleHeap::heapFor(other.slot())->allocate());
  69         set(other.get());
  70     }
  71
  72     template <typename U> Strong(const Strong<U>& other)
  73         : Handle<T>()
  74     {
  75         if (!other.slot())
  76             return;
  77         setSlot(HandleHeap::heapFor(other.slot())->allocate());
  78         set(other.get());
  79     }
  80
  81     enum HashTableDeletedValueTag { HashTableDeletedValue };
  82     bool isHashTableDeletedValue() const { return slot() == hashTableDeletedValue(); }
  83     Strong(HashTableDeletedValueTag)
  84         : Handle<T>(hashTableDeletedValue())
  85     {
  86     }
  87
  88     ~Strong()
  89     {
  90         clear();
  91     }
  92
  93     void swap(Strong& other)
  94     {
  95         Handle<T>::swap(other);
  96     }
  97
  98     void set(JSGlobalData& globalData, ExternalType value)
  99     {
 100         if (!slot())
 101             setSlot(allocateGlobalHandle(globalData));
 102         set(value);
 103     }
 104
 105     template <typename U> Strong& operator=(const Strong<U>& other)
 106     {
 107         if (!other.slot()) {
 108             clear();
 109             return *this;
 110         }
 111
 112         set(*HandleHeap::heapFor(other.slot())->globalData(), other.get());
 113         return *this;
 114     }
 115
 116     Strong& operator=(const Strong& other)
 117     {
 118         if (!other.slot()) {
 119             clear();
 120             return *this;
 121         }
 122
 123         set(*HandleHeap::heapFor(other.slot())->globalData(), other.get());
 124         return *this;
 125     }
 126
 127     void clear()
 128     {
 129         if (!slot())
 130             return;
 131         HandleHeap::heapFor(slot())->deallocate(slot());
 132         setSlot(0);
 133     }
 134
 135 private:
 136     static HandleSlot hashTableDeletedValue() { return reinterpret_cast<HandleSlot>(-1); }
 137
 138     void set(ExternalType externalType)
 139     {
 140         ASSERT(slot());
 141         JSValue value = HandleTypes<T>::toJSValue(externalType);
 142         HandleHeap::heapFor(slot())->writeBarrier(slot(), value);
 143         *slot() = value;
 144     }
 145 };
 146
 147 template<class T> inline void swap(Strong<T>& a, Strong<T>& b)
 148 {
 149     a.swap(b);
 150 }
 151
 152 } // namespace JSC
 153
 154 namespace WTF {
 155
 156 template<typename T> struct VectorTraits<JSC::Strong<T> > : SimpleClassVectorTraits {
 157     static const bool canCompareWithMemcmp = false;
 158 };
 159
 160 template<typename P> struct HashTraits<JSC::Strong<P> > : SimpleClassHashTraits<JSC::Strong<P> > { };
 161
 162 }
 163
 164 #endif // Strong_h