LCOV - code coverage report
Current view: top level - usr/include/x86_64-linux-gnu/qt5/QtCore - qpointer.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 10 0.0 %
Date: 2016-09-12 13:07:23 Functions: 0 6 0.0 %

          Line data    Source code
       1             : /****************************************************************************
       2             : **
       3             : ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
       4             : ** Contact: http://www.qt-project.org/legal
       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 Digia.  For licensing terms and
      14             : ** conditions see http://qt.digia.com/licensing.  For further information
      15             : ** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software
      20             : ** Foundation and appearing in the file LICENSE.LGPL included in the
      21             : ** packaging of this file.  Please review the following information to
      22             : ** ensure the GNU Lesser General Public License version 2.1 requirements
      23             : ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
      24             : **
      25             : ** In addition, as a special exception, Digia gives you certain additional
      26             : ** rights.  These rights are described in the Digia Qt LGPL Exception
      27             : ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
      28             : **
      29             : ** GNU General Public License Usage
      30             : ** Alternatively, this file may be used under the terms of the GNU
      31             : ** General Public License version 3.0 as published by the Free Software
      32             : ** Foundation and appearing in the file LICENSE.GPL included in the
      33             : ** packaging of this file.  Please review the following information to
      34             : ** ensure the GNU General Public License version 3.0 requirements will be
      35             : ** met: http://www.gnu.org/copyleft/gpl.html.
      36             : **
      37             : **
      38             : ** $QT_END_LICENSE$
      39             : **
      40             : ****************************************************************************/
      41             : 
      42             : #ifndef QPOINTER_H
      43             : #define QPOINTER_H
      44             : 
      45             : #include <QtCore/qsharedpointer.h>
      46             : 
      47             : #ifndef QT_NO_QOBJECT
      48             : 
      49             : QT_BEGIN_NAMESPACE
      50             : 
      51             : class QVariant;
      52             : 
      53             : template <class T>
      54             : class QPointer
      55             : {
      56             :     template<typename U>
      57             :     struct TypeSelector
      58             :     {
      59             :         typedef QObject Type;
      60             :     };
      61             :     template<typename U>
      62             :     struct TypeSelector<const U>
      63             :     {
      64             :         typedef const QObject Type;
      65             :     };
      66             :     typedef typename TypeSelector<T>::Type QObjectType;
      67             :     QWeakPointer<QObjectType> wp;
      68             : public:
      69           0 :     inline QPointer() { }
      70             :     inline QPointer(T *p) : wp(p, true) { }
      71             :     // compiler-generated copy/move ctor/assignment operators are fine!
      72           0 :     inline ~QPointer() { }
      73             : 
      74           0 :     inline QPointer<T> &operator=(T* p)
      75           0 :     { wp.assign(static_cast<QObjectType*>(p)); return *this; }
      76             : 
      77           0 :     inline T* data() const
      78           0 :     { return static_cast<T*>( wp.data()); }
      79           0 :     inline T* operator->() const
      80           0 :     { return data(); }
      81             :     inline T& operator*() const
      82             :     { return *data(); }
      83           0 :     inline operator T*() const
      84           0 :     { return data(); }
      85             : 
      86             :     inline bool isNull() const
      87             :     { return wp.isNull(); }
      88             : 
      89             :     inline void clear()
      90             :     { wp.clear(); }
      91             : };
      92             : template <class T> Q_DECLARE_TYPEINFO_BODY(QPointer<T>, Q_MOVABLE_TYPE);
      93             : 
      94             : template <class T>
      95             : inline bool operator==(const T *o, const QPointer<T> &p)
      96             : { return o == p.operator->(); }
      97             : 
      98             : template<class T>
      99             : inline bool operator==(const QPointer<T> &p, const T *o)
     100             : { return p.operator->() == o; }
     101             : 
     102             : template <class T>
     103             : inline bool operator==(T *o, const QPointer<T> &p)
     104             : { return o == p.operator->(); }
     105             : 
     106             : template<class T>
     107             : inline bool operator==(const QPointer<T> &p, T *o)
     108             : { return p.operator->() == o; }
     109             : 
     110             : template<class T>
     111             : inline bool operator==(const QPointer<T> &p1, const QPointer<T> &p2)
     112             : { return p1.operator->() == p2.operator->(); }
     113             : 
     114             : template <class T>
     115             : inline bool operator!=(const T *o, const QPointer<T> &p)
     116             : { return o != p.operator->(); }
     117             : 
     118             : template<class T>
     119             : inline bool operator!= (const QPointer<T> &p, const T *o)
     120             : { return p.operator->() != o; }
     121             : 
     122             : template <class T>
     123             : inline bool operator!=(T *o, const QPointer<T> &p)
     124             : { return o != p.operator->(); }
     125             : 
     126             : template<class T>
     127             : inline bool operator!= (const QPointer<T> &p, T *o)
     128             : { return p.operator->() != o; }
     129             : 
     130             : template<class T>
     131             : inline bool operator!= (const QPointer<T> &p1, const QPointer<T> &p2)
     132             : { return p1.operator->() != p2.operator->() ; }
     133             : 
     134             : template<typename T>
     135             : QPointer<T>
     136             : qPointerFromVariant(const QVariant &variant)
     137             : {
     138             :     return QPointer<T>(qobject_cast<T*>(QtSharedPointer::weakPointerFromVariant_internal(variant).data()));
     139             : }
     140             : 
     141             : QT_END_NAMESPACE
     142             : 
     143             : #endif // QT_NO_QOBJECT
     144             : 
     145             : #endif // QPOINTER_H

Generated by: LCOV version 1.11