JavaScriptCore-903.tar.gz

[apple/javascriptcore.git] / runtime / Protect.h

diff --git a/runtime/Protect.h b/runtime/Protect.h
index a0d5443dce723923e09c0c524a5231dae9b9c709..843c9e11148cc70a67cdb6625447263168bff7a8 100644 (file)
--- a/runtime/Protect.h
+++ b/runtime/Protect.h
@@ -22,7 +22,7 @@
 #ifndef Protect_h
 #define Protect_h
 
-#include "Collector.h"
+#include "Heap.h"
 #include "JSValue.h"
 
 namespace JSC {
@@ -52,164 +52,15 @@ namespace JSC {
     inline void gcProtect(JSValue value)
     {
         if (value && value.isCell())
-            gcProtect(asCell(value));
+            gcProtect(value.asCell());
     }
 
     inline void gcUnprotect(JSValue value)
     {
         if (value && value.isCell())
-            gcUnprotect(asCell(value));
+            gcUnprotect(value.asCell());
     }
 
-    // FIXME: Share more code with RefPtr template? The only differences are the ref/deref operation
-    // and the implicit conversion to raw pointer
-    template <class T> class ProtectedPtr {
-    public:
-        ProtectedPtr() : m_ptr(0) {}
-        ProtectedPtr(T* ptr);
-        ProtectedPtr(const ProtectedPtr&);
-        ~ProtectedPtr();
-
-        template <class U> ProtectedPtr(const ProtectedPtr<U>&);
-        
-        T* get() const { return m_ptr; }
-        operator T*() const { return m_ptr; }
-        operator JSValue() const { return JSValue(m_ptr); }
-        T* operator->() const { return m_ptr; }
-        
-        operator bool() const { return m_ptr; }
-        bool operator!() const { return !m_ptr; }
-
-        ProtectedPtr& operator=(const ProtectedPtr&);
-        ProtectedPtr& operator=(T*);
-        
-    private:
-        T* m_ptr;
-    };
-
-    class ProtectedJSValue {
-    public:
-        ProtectedJSValue() {}
-        ProtectedJSValue(JSValue value);
-        ProtectedJSValue(const ProtectedJSValue&);
-        ~ProtectedJSValue();
-
-        template <class U> ProtectedJSValue(const ProtectedPtr<U>&);
-        
-        JSValue get() const { return m_value; }
-        operator JSValue() const { return m_value; }
-        JSValue operator->() const { return m_value; }
-        
-        operator bool() const { return m_value; }
-        bool operator!() const { return !m_value; }
-
-        ProtectedJSValue& operator=(const ProtectedJSValue&);
-        ProtectedJSValue& operator=(JSValue);
-        
-    private:
-        JSValue m_value;
-    };
-
-    template <class T> inline ProtectedPtr<T>::ProtectedPtr(T* ptr)
-        : m_ptr(ptr)
-    {
-        gcProtectNullTolerant(m_ptr);
-    }
-
-    template <class T> inline ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr& o)
-        : m_ptr(o.get())
-    {
-        gcProtectNullTolerant(m_ptr);
-    }
-
-    template <class T> inline ProtectedPtr<T>::~ProtectedPtr()
-    {
-        gcUnprotectNullTolerant(m_ptr);
-    }
-
-    template <class T> template <class U> inline ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr<U>& o)
-        : m_ptr(o.get())
-    {
-        gcProtectNullTolerant(m_ptr);
-    }
-
-    template <class T> inline ProtectedPtr<T>& ProtectedPtr<T>::operator=(const ProtectedPtr<T>& o) 
-    {
-        T* optr = o.m_ptr;
-        gcProtectNullTolerant(optr);
-        gcUnprotectNullTolerant(m_ptr);
-        m_ptr = optr;
-        return *this;
-    }
-
-    template <class T> inline ProtectedPtr<T>& ProtectedPtr<T>::operator=(T* optr)
-    {
-        gcProtectNullTolerant(optr);
-        gcUnprotectNullTolerant(m_ptr);
-        m_ptr = optr;
-        return *this;
-    }
-
-    inline ProtectedJSValue::ProtectedJSValue(JSValue value)
-        : m_value(value)
-    {
-        gcProtect(m_value);
-    }
-
-    inline ProtectedJSValue::ProtectedJSValue(const ProtectedJSValue& o)
-        : m_value(o.get())
-    {
-        gcProtect(m_value);
-    }
-
-    inline ProtectedJSValue::~ProtectedJSValue()
-    {
-        gcUnprotect(m_value);
-    }
-
-    template <class U> ProtectedJSValue::ProtectedJSValue(const ProtectedPtr<U>& o)
-        : m_value(o.get())
-    {
-        gcProtect(m_value);
-    }
-
-    inline ProtectedJSValue& ProtectedJSValue::operator=(const ProtectedJSValue& o) 
-    {
-        JSValue ovalue = o.m_value;
-        gcProtect(ovalue);
-        gcUnprotect(m_value);
-        m_value = ovalue;
-        return *this;
-    }
-
-    inline ProtectedJSValue& ProtectedJSValue::operator=(JSValue ovalue)
-    {
-        gcProtect(ovalue);
-        gcUnprotect(m_value);
-        m_value = ovalue;
-        return *this;
-    }
-
-    template <class T> inline bool operator==(const ProtectedPtr<T>& a, const ProtectedPtr<T>& b) { return a.get() == b.get(); }
-    template <class T> inline bool operator==(const ProtectedPtr<T>& a, const T* b) { return a.get() == b; }
-    template <class T> inline bool operator==(const T* a, const ProtectedPtr<T>& b) { return a == b.get(); }
-
-    template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const ProtectedPtr<T>& b) { return a.get() != b.get(); }
-    template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const T* b) { return a.get() != b; }
-    template <class T> inline bool operator!=(const T* a, const ProtectedPtr<T>& b) { return a != b.get(); }
-
-    inline bool operator==(const ProtectedJSValue& a, const ProtectedJSValue& b) { return a.get() == b.get(); }
-    inline bool operator==(const ProtectedJSValue& a, const JSValue b) { return a.get() == b; }
-    template <class T> inline bool operator==(const ProtectedJSValue& a, const ProtectedPtr<T>& b) { return a.get() == JSValue(b.get()); }
-    inline bool operator==(const JSValue a, const ProtectedJSValue& b) { return a == b.get(); }
-    template <class T> inline bool operator==(const ProtectedPtr<T>& a, const ProtectedJSValue& b) { return JSValue(a.get()) == b.get(); }
-
-    inline bool operator!=(const ProtectedJSValue& a, const ProtectedJSValue& b) { return a.get() != b.get(); }
-    inline bool operator!=(const ProtectedJSValue& a, const JSValue b) { return a.get() != b; }
-    template <class T> inline bool operator!=(const ProtectedJSValue& a, const ProtectedPtr<T>& b) { return a.get() != JSValue(b.get()); }
-    inline bool operator!=(const JSValue a, const ProtectedJSValue& b) { return a != b.get(); }
-    template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const ProtectedJSValue& b) { return JSValue(a.get()) != b.get(); }
- 
 } // namespace JSC
 
 #endif // Protect_h