1 | /**************************************************************************** |
---|---|

2 | ** |

3 | ** Copyright (C) 2016 The Qt Company Ltd. |

4 | ** Contact: https://www.qt.io/licensing/ |

5 | ** |

6 | ** This file is part of the QtCore module of the Qt Toolkit. |

7 | ** |

8 | ** $QT_BEGIN_LICENSE:LGPL$ |

9 | ** Commercial License Usage |

10 | ** Licensees holding valid commercial Qt licenses may use this file in |

11 | ** accordance with the commercial license agreement provided with the |

12 | ** Software or, alternatively, in accordance with the terms contained in |

13 | ** a written agreement between you and The Qt Company. For licensing terms |

14 | ** and conditions see https://www.qt.io/terms-conditions. For further |

15 | ** information use the contact form at https://www.qt.io/contact-us. |

16 | ** |

17 | ** GNU Lesser General Public License Usage |

18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |

19 | ** General Public License version 3 as published by the Free Software |

20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |

21 | ** packaging of this file. Please review the following information to |

22 | ** ensure the GNU Lesser General Public License version 3 requirements |

23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |

24 | ** |

25 | ** GNU General Public License Usage |

26 | ** Alternatively, this file may be used under the terms of the GNU |

27 | ** General Public License version 2.0 or (at your option) the GNU General |

28 | ** Public license version 3 or any later version approved by the KDE Free |

29 | ** Qt Foundation. The licenses are as published by the Free Software |

30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |

31 | ** included in the packaging of this file. Please review the following |

32 | ** information to ensure the GNU General Public License requirements will |

33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |

34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |

35 | ** |

36 | ** $QT_END_LICENSE$ |

37 | ** |

38 | ****************************************************************************/ |

39 | |

40 | #ifndef QPOINTER_H |

41 | #define QPOINTER_H |

42 | |

43 | #include <QtCore/qsharedpointer.h> |

44 | #include <QtCore/qtypeinfo.h> |

45 | |

46 | #ifndef QT_NO_QOBJECT |

47 | |

48 | QT_BEGIN_NAMESPACE |

49 | |

50 | class QVariant; |

51 | |

52 | template <class T> |

53 | class QPointer |

54 | { |

55 | Q_STATIC_ASSERT_X(!std::is_pointer<T>::value, "QPointer's template type must not be a pointer type"); |

56 | |

57 | using QObjectType = |

58 | typename std::conditional<std::is_const<T>::value, const QObject, QObject>::type; |

59 | QWeakPointer<QObjectType> wp; |

60 | public: |

61 | QPointer() = default; |

62 | inline QPointer(T *p) : wp(p, true) { } |

63 | // compiler-generated copy/move ctor/assignment operators are fine! |

64 | // compiler-generated dtor is fine! |

65 | |

66 | #ifdef Q_QDOC |

67 | // Stop qdoc from complaining about missing function |

68 | ~QPointer(); |

69 | #endif |

70 | |

71 | inline void swap(QPointer &other) noexcept { wp.swap(other.wp); } |

72 | |

73 | inline QPointer<T> &operator=(T* p) |

74 | { wp.assign(static_cast<QObjectType*>(p)); return *this; } |

75 | |

76 | inline T* data() const |

77 | { return static_cast<T*>(wp.internalData()); } |

78 | inline T* operator->() const |

79 | { return data(); } |

80 | inline T& operator*() const |

81 | { return *data(); } |

82 | inline operator T*() const |

83 | { return data(); } |

84 | |

85 | inline bool isNull() const |

86 | { return wp.isNull(); } |

87 | |

88 | inline void clear() |

89 | { wp.clear(); } |

90 | }; |

91 | template <class T> Q_DECLARE_TYPEINFO_BODY(QPointer<T>, Q_MOVABLE_TYPE); |

92 | |

93 | template <class T> |

94 | inline bool operator==(const T *o, const QPointer<T> &p) |

95 | { return o == p.operator->(); } |

96 | |

97 | template<class T> |

98 | inline bool operator==(const QPointer<T> &p, const T *o) |

99 | { return p.operator->() == o; } |

100 | |

101 | template <class T> |

102 | inline bool operator==(T *o, const QPointer<T> &p) |

103 | { return o == p.operator->(); } |

104 | |

105 | template<class T> |

106 | inline bool operator==(const QPointer<T> &p, T *o) |

107 | { return p.operator->() == o; } |

108 | |

109 | template<class T> |

110 | inline bool operator==(const QPointer<T> &p1, const QPointer<T> &p2) |

111 | { return p1.operator->() == p2.operator->(); } |

112 | |

113 | template <class T> |

114 | inline bool operator!=(const T *o, const QPointer<T> &p) |

115 | { return o != p.operator->(); } |

116 | |

117 | template<class T> |

118 | inline bool operator!= (const QPointer<T> &p, const T *o) |

119 | { return p.operator->() != o; } |

120 | |

121 | template <class T> |

122 | inline bool operator!=(T *o, const QPointer<T> &p) |

123 | { return o != p.operator->(); } |

124 | |

125 | template<class T> |

126 | inline bool operator!= (const QPointer<T> &p, T *o) |

127 | { return p.operator->() != o; } |

128 | |

129 | template<class T> |

130 | inline bool operator!= (const QPointer<T> &p1, const QPointer<T> &p2) |

131 | { return p1.operator->() != p2.operator->() ; } |

132 | |

133 | template<typename T> |

134 | QPointer<T> |

135 | qPointerFromVariant(const QVariant &variant) |

136 | { |

137 | const auto wp = QtSharedPointer::weakPointerFromVariant_internal(variant); |

138 | return QPointer<T>{qobject_cast<T*>(QtPrivate::EnableInternalData::internalData(p: wp))}; |

139 | } |

140 | |

141 | template <class T> |

142 | inline void swap(QPointer<T> &p1, QPointer<T> &p2) noexcept |

143 | { p1.swap(p2); } |

144 | |

145 | QT_END_NAMESPACE |

146 | |

147 | #endif // QT_NO_QOBJECT |

148 | |

149 | #endif // QPOINTER_H |

150 |