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 | template<typename U> |

58 | struct TypeSelector |

59 | { |

60 | typedef QObject Type; |

61 | }; |

62 | template<typename U> |

63 | struct TypeSelector<const U> |

64 | { |

65 | typedef const QObject Type; |

66 | }; |

67 | typedef typename TypeSelector<T>::Type QObjectType; |

68 | QWeakPointer<QObjectType> wp; |

69 | public: |

70 | inline QPointer() { } |

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

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

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

74 | |

75 | #ifdef Q_QDOC |

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

77 | ~QPointer(); |

78 | #endif |

79 | |

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

81 | |

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

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

84 | |

85 | inline T* data() const |

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

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

88 | { return data(); } |

89 | inline T& operator*() const |

90 | { return *data(); } |

91 | inline operator T*() const |

92 | { return data(); } |

93 | |

94 | inline bool isNull() const |

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

96 | |

97 | inline void clear() |

98 | { wp.clear(); } |

99 | }; |

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

101 | |

102 | template <class T> |

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

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

105 | |

106 | template<class T> |

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

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

109 | |

110 | template <class T> |

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

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

113 | |

114 | template<class T> |

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

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

117 | |

118 | template<class T> |

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

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

121 | |

122 | template <class T> |

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

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

125 | |

126 | template<class T> |

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

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

129 | |

130 | template <class T> |

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

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

133 | |

134 | template<class T> |

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

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

137 | |

138 | template<class T> |

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

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

141 | |

142 | template<typename T> |

143 | QPointer<T> |

144 | qPointerFromVariant(const QVariant &variant) |

145 | { |

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

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

148 | } |

149 | |

150 | template <class T> |

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

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

153 | |

154 | QT_END_NAMESPACE |

155 | |

156 | #endif // QT_NO_QOBJECT |

157 | |

158 | #endif // QPOINTER_H |

159 |