first commit

project/fm_viewer/fav/SharedPtr.h

@@ -0,0 +1,105 @@
+/******************************************************************************
+    QtAV:  Multimedia framework based on Qt and FFmpeg
+    Copyright (C) 2012-2016 Wang Bin <wbsecg1@gmail.com>
+
+*   This file is part of QtAV (from 2014)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+******************************************************************************/
+
+#ifndef SHARED_PTR
+#define SHARED_PTR
+
+#include <algorithm>
+#include <QtCore/QAtomicInt>
+/*
+ * a simple thread safe shared ptr. QSharedPointer does not provide a way to get how many the ref count is.
+ */
+
+namespace impl {
+template <typename T>
+class SharedPtrImpl {
+public:
+    explicit SharedPtrImpl(T *ptr = 0) : m_ptr(ptr), m_counter(1) { }
+    ~SharedPtrImpl() { delete m_ptr;}
+    T * operator->() const { return m_ptr;}
+    T & operator*() const { return *m_ptr;}
+    T * get() const { return m_ptr;}
+    void ref() { m_counter.ref(); }
+    // return false if becomes 0
+    bool deref() { return m_counter.deref();}
+    int count() const {
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0) || QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
+        return m_counter;
+#else
+        return m_counter.load();
+#endif
+    }
+    bool isNull() const { return !m_ptr;}
+private:
+    T *m_ptr;
+    QAtomicInt m_counter;
+};
+} // namespace impl
+
+template <typename T>
+class SharedPtr {
+public:
+    explicit SharedPtr(T *ptr = 0) : m_impl(new impl::SharedPtrImpl<T>(ptr)) { }
+    template <typename U>
+    explicit SharedPtr(U *ptr = 0) : m_impl(new impl::SharedPtrImpl<T>(ptr)) { }
+    ~SharedPtr() {
+        if (!m_impl->deref())
+            delete m_impl;
+    }
+    SharedPtr(const SharedPtr &other) {
+        m_impl = other.m_impl;
+        m_impl->ref();
+    }
+    template <typename U>
+    SharedPtr(const SharedPtr<U> &other) {
+        m_impl = other.m_impl;
+        m_impl->ref();
+    }
+    SharedPtr & operator=(const SharedPtr &other) {
+        SharedPtr tmp(other);
+        swap(tmp);
+        return *this;
+    }
+    template <typename U>
+    SharedPtr<T> & operator=(const SharedPtr<U> &other) {
+        SharedPtr<T> tmp(other);
+        swap(tmp);
+        return *this;
+    }
+    T * operator->() const { return m_impl->operator->();}
+    T & operator*() const { return **m_impl;}
+    bool operator !() const { return isNull();}
+    template <typename U>
+    bool operator<(const SharedPtr<U> &other) {  return m_impl->get() < other.get();}
+    bool isNull() const { return m_impl->isNull();}
+    T * get() const {  return m_impl->get();}
+    int count() const { return m_impl->count();}
+    void swap(SharedPtr<T> &other) { std::swap(m_impl, other.m_impl);}
+private:
+    impl::SharedPtrImpl<T> *m_impl;
+};
+
+template <typename T>
+void swap(SharedPtr<T> &left, SharedPtr<T> &right) {
+    left.swap(right);
+}
+
+#endif //SHARED_PTR