106 lines
3.4 KiB
C++
106 lines
3.4 KiB
C++
/******************************************************************************
|
|
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
|