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 <wtf/Assertions.h>
  30 #include "Handle.h"
  31 #include "HandleSet.h"
  32
  33 namespace JSC {
  34
  35 class JSGlobalData;
  36
  37 // A strongly referenced handle that prevents the object it points to from being garbage collected.
  38 template <typename T> class Strong : public Handle<T> {
  39     using Handle<T>::slot;
  40     using Handle<T>::setSlot;
  41
  42 public:
  43     typedef typename Handle<T>::ExternalType ExternalType;
  44
  45     Strong()
  46         : Handle<T>()
  47     {
  48     }
  49
  50     Strong(JSGlobalData&, ExternalType = ExternalType());
  51
  52     Strong(JSGlobalData&, Handle<T>);
  53
  54     Strong(const Strong& other)
  55         : Handle<T>()
  56     {
  57         if (!other.slot())
  58             return;
  59         setSlot(HandleSet::heapFor(other.slot())->allocate());
  60         set(other.get());
  61     }
  62
  63     template <typename U> Strong(const Strong<U>& other)
  64         : Handle<T>()
  65     {
  66         if (!other.slot())
  67             return;
  68         setSlot(HandleSet::heapFor(other.slot())->allocate());
  69         set(other.get());
  70     }
  71
  72     enum HashTableDeletedValueTag { HashTableDeletedValue };
  73     bool isHashTableDeletedValue() const { return slot() == hashTableDeletedValue(); }
  74     Strong(HashTableDeletedValueTag)
  75         : Handle<T>(hashTableDeletedValue())
  76     {
  77     }
  78
  79     ~Strong()
  80     {
  81         clear();
  82     }
  83
  84     bool operator!() const { return !slot() || !*slot(); }
  85
  86     // This conversion operator allows implicit conversion to bool but not to other integer types.
  87     typedef JSValue (HandleBase::*UnspecifiedBoolType);
  88     operator UnspecifiedBoolType*() const { return !!*this ? reinterpret_cast<UnspecifiedBoolType*>(1) : 0; }
  89
  90     void swap(Strong& other)
  91     {
  92         Handle<T>::swap(other);
  93     }
  94
  95     ExternalType get() const { return HandleTypes<T>::getFromSlot(this->slot()); }
  96
  97     void set(JSGlobalData&, ExternalType);
  98
  99     template <typename U> Strong& operator=(const Strong<U>& other)
 100     {
 101         if (!other.slot()) {
 102             clear();
 103             return *this;
 104         }
 105
 106         set(*HandleSet::heapFor(other.slot())->globalData(), other.get());
 107         return *this;
 108     }
 109
 110     Strong& operator=(const Strong& other)
 111     {
 112         if (!other.slot()) {
 113             clear();
 114             return *this;
 115         }
 116
 117         set(*HandleSet::heapFor(other.slot())->globalData(), other.get());
 118         return *this;
 119     }
 120
 121     void clear()
 122     {
 123         if (!slot())
 124             return;
 125         HandleSet::heapFor(slot())->deallocate(slot());
 126         setSlot(0);
 127     }
 128
 129 private:
 130     static HandleSlot hashTableDeletedValue() { return reinterpret_cast<HandleSlot>(-1); }
 131
 132     void set(ExternalType externalType)
 133     {
 134         ASSERT(slot());
 135         JSValue value = HandleTypes<T>::toJSValue(externalType);
 136         HandleSet::heapFor(slot())->writeBarrier(slot(), value);
 137         *slot() = value;
 138     }
 139 };
 140
 141 template<class T> inline void swap(Strong<T>& a, Strong<T>& b)
 142 {
 143     a.swap(b);
 144 }
 145
 146 } // namespace JSC
 147
 148 namespace WTF {
 149
 150 template<typename T> struct VectorTraits<JSC::Strong<T> > : SimpleClassVectorTraits {
 151     static const bool canCompareWithMemcmp = false;
 152 };
 153
 154 template<typename P> struct HashTraits<JSC::Strong<P> > : SimpleClassHashTraits<JSC::Strong<P> > { };
 155
 156 }
 157
 158 #endif // Strong_h