初始化

cocos2d-x/cocos/base/CCRefPtr.h

@@ -0,0 +1,348 @@
+/****************************************************************************
+ Copyright (c) 2014      PlayFirst Inc.
+ Copyright (c) 2014-2016 Chukong Technologies Inc.
+ Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+#ifndef __CC_REF_PTR_H__
+#define __CC_REF_PTR_H__
+/// @cond DO_NOT_SHOW
+
+#include "base/CCRef.h"
+#include "base/ccMacros.h"
+#include <functional>
+#include <type_traits>
+
+NS_CC_BEGIN
+
+/**
+ * Utility/support macros. Defined to enable RefPtr<T> to contain types like 'const T' because we do not
+ * regard retain()/release() as affecting mutability of state.
+ */
+#define CC_REF_PTR_SAFE_RETAIN(ptr)\
+    \
+    do\
+    {\
+        if (ptr)\
+        {\
+            const_cast<Ref*>(static_cast<const Ref*>(ptr))->retain();\
+        }\
+    \
+    }   while (0);
+
+#define CC_REF_PTR_SAFE_RELEASE(ptr)\
+    \
+    do\
+    {\
+        if (ptr)\
+        {\
+            const_cast<Ref*>(static_cast<const Ref*>(ptr))->release();\
+        }\
+    \
+    }   while (0);
+
+#define CC_REF_PTR_SAFE_RELEASE_NULL(ptr)\
+    \
+    do\
+    {\
+        if (ptr)\
+        {\
+            const_cast<Ref*>(static_cast<const Ref*>(ptr))->release();\
+            ptr = nullptr;\
+        }\
+    \
+    }   while (0);
+
+/**
+ * Wrapper class which maintains a strong reference to a cocos2dx cocos2d::Ref* type object.
+ * Similar in concept to a boost smart pointer.
+ *
+ * Enables the use of the RAII idiom with Cocos2dx objects and helps automate some of the more
+ * mundane tasks of pointer initialization and cleanup.
+ *
+ * The class itself is modelled on C++ 11 std::shared_ptr, and trys to keep some of the methods
+ * and functionality consistent with std::shared_ptr.
+ */
+template <typename T> class RefPtr
+{
+public:
+
+    inline RefPtr()
+        : _ptr(nullptr)
+    {
+
+    }
+
+    inline RefPtr(RefPtr<T> && other)
+    {
+        _ptr = other._ptr;
+        other._ptr = nullptr;
+    }
+
+    inline RefPtr(T * ptr)
+        : _ptr(ptr)
+    {
+        CC_REF_PTR_SAFE_RETAIN(_ptr);
+    }
+
+    inline RefPtr(std::nullptr_t ptr)
+        : _ptr(nullptr)
+    {
+
+    }
+
+    inline RefPtr(const RefPtr<T> & other)
+        : _ptr(other._ptr)
+    {
+        CC_REF_PTR_SAFE_RETAIN(_ptr);
+    }
+
+    inline ~RefPtr()
+    {
+        CC_REF_PTR_SAFE_RELEASE_NULL(_ptr);
+    }
+
+    inline RefPtr<T> & operator = (const RefPtr<T> & other)
+    {
+        if (other._ptr != _ptr)
+        {
+            CC_REF_PTR_SAFE_RETAIN(other._ptr);
+            CC_REF_PTR_SAFE_RELEASE(_ptr);
+            _ptr = other._ptr;
+        }
+
+        return *this;
+    }
+
+    inline RefPtr<T> & operator = (RefPtr<T> && other)
+    {
+        if (&other != this)
+        {
+            CC_REF_PTR_SAFE_RELEASE(_ptr);
+            _ptr = other._ptr;
+            other._ptr = nullptr;
+        }
+
+        return *this;
+    }
+
+    inline RefPtr<T> & operator = (T * other)
+    {
+        if (other != _ptr)
+        {
+            CC_REF_PTR_SAFE_RETAIN(other);
+            CC_REF_PTR_SAFE_RELEASE(_ptr);
+            _ptr = other;
+        }
+
+        return *this;
+    }
+
+    inline RefPtr<T> & operator = (std::nullptr_t other)
+    {
+        CC_REF_PTR_SAFE_RELEASE_NULL(_ptr);
+        return *this;
+    }
+
+    inline operator T * () const { return _ptr; }
+    
+    inline T & operator * () const
+    {
+        CCASSERT(_ptr, "Attempt to dereference a null pointer!");
+        return *_ptr;
+    }
+
+    inline T * operator->() const
+    {
+        CCASSERT(_ptr, "Attempt to dereference a null pointer!");
+        return _ptr;
+    }
+
+    inline T * get() const { return _ptr; }
+
+
+    inline bool operator == (const RefPtr<T> & other) const { return _ptr == other._ptr; }
+
+    inline bool operator == (const T * other) const { return _ptr == other; }
+
+    inline bool operator == (typename std::remove_const<T>::type * other) const { return _ptr == other; }
+
+    inline bool operator == (const std::nullptr_t other) const { return _ptr == other; }
+
+
+    inline bool operator != (const RefPtr<T> & other) const { return _ptr != other._ptr; }
+
+    inline bool operator != (const T * other) const { return _ptr != other; }
+
+    inline bool operator != (typename std::remove_const<T>::type * other) const { return _ptr != other; }
+
+    inline bool operator != (const std::nullptr_t other) const { return _ptr != other; }
+
+
+    inline bool operator > (const RefPtr<T> & other) const { return _ptr > other._ptr; }
+
+    inline bool operator > (const T * other) const { return _ptr > other; }
+
+    inline bool operator > (typename std::remove_const<T>::type * other) const { return _ptr > other; }
+
+
+    inline bool operator < (const RefPtr<T> & other) const { return _ptr < other._ptr; }
+
+    inline bool operator < (const T * other) const { return _ptr < other; }
+
+    inline bool operator < (typename std::remove_const<T>::type * other) const { return _ptr < other; }
+
+
+    inline bool operator >= (const RefPtr<T> & other) const { return _ptr >= other._ptr; }
+
+    inline bool operator >= (const T * other) const { return _ptr >= other; }
+
+    inline bool operator >= (typename std::remove_const<T>::type * other) const { return _ptr >= other; }
+
+
+    inline bool operator <= (const RefPtr<T> & other) const { return _ptr <= other._ptr; }
+
+    inline bool operator <= (const T * other) const { return _ptr <= other; }
+
+    inline bool operator <= (typename std::remove_const<T>::type * other) const { return _ptr <= other; }
+
+
+    inline operator bool() const { return _ptr != nullptr; }
+
+    inline void reset()
+    {
+        CC_REF_PTR_SAFE_RELEASE_NULL(_ptr);
+    }
+
+    inline void swap(RefPtr<T> & other)
+    {
+        if (&other != this)
+        {
+            T * tmp = _ptr;
+            _ptr = other._ptr;
+            other._ptr = tmp;
+        }
+    }
+
+    /**
+     * This function assigns to this RefPtr<T> but does not increase the reference count of the object pointed to.
+     * Useful for assigning an object created through the 'new' operator to a RefPtr<T>. Basically used in scenarios
+     * where the RefPtr<T> has the initial ownership of the object.
+     *
+     * E.G:
+     *      RefPtr<cocos2d::Image> image;
+     *      image.weakAssign(new cocos2d::Image());
+     *
+     * Instead of:
+     *      RefPtr<cocos2d::Image> image;
+     *      image = new cocos2d::Image();
+     *      image->release();               // Required because new'd object already has a reference count of '1'.
+     */
+    inline void weakAssign(const RefPtr<T> & other)
+    {
+        CC_REF_PTR_SAFE_RELEASE(_ptr);
+        _ptr = other._ptr;
+    }
+
+private:
+    T * _ptr;
+
+    // NOTE: We can ensure T is derived from cocos2d::Ref at compile time here.
+    static_assert(std::is_base_of<Ref, typename std::remove_const<T>::type>::value, "T must be derived from Ref");
+};
+
+template<class T> inline
+bool operator<(const RefPtr<T>& r, std::nullptr_t)
+{
+    return std::less<T*>()(r.get(), nullptr);
+}
+
+template<class T> inline
+bool operator<(std::nullptr_t, const RefPtr<T>& r)
+{
+    return std::less<T*>()(nullptr, r.get());
+}
+
+template<class T> inline
+bool operator>(const RefPtr<T>& r, std::nullptr_t)
+{
+    return nullptr < r;
+}
+
+template<class T> inline
+bool operator>(std::nullptr_t, const RefPtr<T>& r)
+{
+    return r < nullptr;
+}
+
+template<class T> inline
+bool operator<=(const RefPtr<T>& r, std::nullptr_t)
+{
+    return !(nullptr < r);
+}
+
+template<class T> inline
+bool operator<=(std::nullptr_t, const RefPtr<T>& r)
+{
+    return !(r < nullptr);
+}
+
+template<class T> inline
+bool operator>=(const RefPtr<T>& r, std::nullptr_t)
+{
+    return !(r < nullptr);
+}
+
+template<class T> inline
+bool operator>=(std::nullptr_t, const RefPtr<T>& r)
+{
+    return !(nullptr < r);
+}
+
+/**
+ * Cast between RefPtr types statically.
+ */
+template<class T, class U> RefPtr<T> static_pointer_cast(const RefPtr<U> & r)
+{
+    return RefPtr<T>(static_cast<T*>(r.get()));
+}
+
+/**
+ * Cast between RefPtr types dynamically.
+ */
+template<class T, class U> RefPtr<T> dynamic_pointer_cast(const RefPtr<U> & r)
+{
+    return RefPtr<T>(dynamic_cast<T*>(r.get()));
+}
+
+/**
+ * Done with these macros.
+ */
+#undef CC_REF_PTR_SAFE_RETAIN
+#undef CC_REF_PTR_SAFE_RELEASE
+#undef CC_REF_PTR_SAFE_RELEASE_NULL
+
+NS_CC_END
+
+/// @endcond
+#endif  // __CC_REF_PTR_H__