qgsrange.h

Go to the documentation of this file.

/***************************************************************************
                             qgsrange.h
                             ----------
    begin                : April 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSRANGE_H
#define QGSRANGE_H
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
 
#include <QDate>
#include <QDateTime>
#include <QString>
 
using namespace Qt::StringLiterals;

template<typename T> class QgsRange
{
  public:
    QgsRange( T lower, T upper, bool includeLower = true, bool includeUpper = true )
      : mLower( lower )
      , mUpper( upper )
      , mIncludeLower( includeLower )
      , mIncludeUpper( includeUpper )
    {}

    QgsRange( T lower, T upper, Qgis::RangeLimits limits )
      : mLower( lower )
      , mUpper( upper )
      , mIncludeLower( limits == Qgis::RangeLimits::IncludeLowerExcludeUpper || limits == Qgis::RangeLimits::IncludeBoth )
      , mIncludeUpper( limits == Qgis::RangeLimits::ExcludeLowerIncludeUpper || limits == Qgis::RangeLimits::IncludeBoth )
    {}

    T lower() const { return mLower; }

    T upper() const { return mUpper; }

    bool includeLower() const { return mIncludeLower; }

    bool includeUpper() const { return mIncludeUpper; }

    Qgis::RangeLimits rangeLimits() const
    {
      if ( mIncludeLower && mIncludeUpper )
        return Qgis::RangeLimits::IncludeBoth;
      else if ( mIncludeLower && !mIncludeUpper )
        return Qgis::RangeLimits::IncludeLowerExcludeUpper;
      else if ( !mIncludeLower && mIncludeUpper )
        return Qgis::RangeLimits::ExcludeLowerIncludeUpper;
      else
        return Qgis::RangeLimits::ExcludeBoth;
    }

    bool isEmpty() const { return mLower > mUpper || ( mUpper == mLower && !( mIncludeLower || mIncludeUpper ) ); }

    bool isSingleton() const { return mLower == mUpper && ( mIncludeLower || mIncludeUpper ); }

    bool contains( const QgsRange<T> &other ) const
    {
      const bool lowerOk = ( mIncludeLower && mLower <= other.mLower ) || ( !mIncludeLower && mLower < other.mLower ) || ( !mIncludeLower && !other.mIncludeLower && mLower <= other.mLower );
      if ( !lowerOk )
        return false;
 
      const bool upperOk = ( mIncludeUpper && mUpper >= other.mUpper ) || ( !mIncludeUpper && mUpper > other.mUpper ) || ( !mIncludeUpper && !other.mIncludeUpper && mUpper >= other.mUpper );
      if ( !upperOk )
        return false;
 
      return true;
    }

    bool contains( T element ) const
    {
      const bool lowerOk = ( mIncludeLower && mLower <= element ) || ( !mIncludeLower && mLower < element );
      if ( !lowerOk )
        return false;
 
      const bool upperOk = ( mIncludeUpper && mUpper >= element ) || ( !mIncludeUpper && mUpper > element );
      if ( !upperOk )
        return false;
 
      return true;
    }

    bool overlaps( const QgsRange<T> &other ) const
    {
      // other range is completely before or completely after self range
      if ( other.mUpper < mLower || other.mLower > mUpper )
        return false;
 
      // other overlaps self for sure
      if ( other.mUpper > mLower && other.mLower < mUpper )
        return true;
 
      if ( other.mUpper == mLower )
        return other.mIncludeUpper && mIncludeLower;
 
      if ( other.mLower == mUpper )
        return other.mIncludeLower && mIncludeUpper;
 
      // UNREACHABLE CODE
      return false;
    }
 
    bool operator==( const QgsRange<T> &other ) const { return mLower == other.mLower && mUpper == other.mUpper && mIncludeLower == other.includeLower() && mIncludeUpper == other.includeUpper(); }
 
    bool operator!=( const QgsRange<T> &other ) const { return ( !operator==( other ) ); }
 
  protected:
    T mLower;
    T mUpper;
    bool mIncludeLower = true;
    bool mIncludeUpper = true;
};
 
// These typedefs are in place to work around a SIP bug:
// https://github.com/Python-SIP/sip/issues/66
#ifndef SIP_RUN
typedef QgsRange<double> QgsRangedoubleBase;
typedef QgsRange<int> QgsRangeintBase;
#endif

class CORE_EXPORT QgsDoubleRange : public QgsRange< double >
{
  public:
    QgsDoubleRange( double lower, double upper, Qgis::RangeLimits limits )
      : QgsRange( lower, upper, limits )
    {}
 
#ifndef SIP_RUN

    QgsDoubleRange( double lower = std::numeric_limits< double >::lowest(), double upper = std::numeric_limits< double >::max(), bool includeLower = true, bool includeUpper = true )
      : QgsRange( lower, upper, includeLower, includeUpper )
    {}
#else

    QgsDoubleRange( double lower, double upper, bool includeLower = true, bool includeUpper = true )
      : QgsRange( lower, upper, includeLower, includeUpper )
    {}

    QgsDoubleRange()
      : QgsRange( std::numeric_limits< double >::lowest(), std::numeric_limits< double >::max(), true, true )
    {}
#endif

    bool isInfinite() const { return lower() == std::numeric_limits< double >::lowest() && upper() == std::numeric_limits< double >::max(); }
 
#ifdef SIP_RUN
    // clang-format off
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = u"<QgsDoubleRange: %1%2, %3%4>"_s.arg( sipCpp->includeLower() ? u"["_s : u"("_s )
                  .arg( sipCpp->lower() )
                  .arg( sipCpp->upper() )
                  .arg( sipCpp->includeUpper() ? u"]"_s : u")"_s );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
// clang-format on
#endif
 
      bool operator==( const QgsDoubleRange &other ) const
    {
      return qgsDoubleNear( mLower, other.mLower ) && qgsDoubleNear( mUpper, other.mUpper ) && mIncludeLower == other.includeLower() && mIncludeUpper == other.includeUpper();
    }
 
    bool operator!=( const QgsDoubleRange &other ) const { return ( !operator==( other ) ); }
};
 
Q_DECLARE_METATYPE( QgsDoubleRange )
 
 

class CORE_EXPORT QgsIntRange : public QgsRange< int >
{
  public:
    QgsIntRange( int lower, int upper, Qgis::RangeLimits limits )
      : QgsRange( lower, upper, limits )
    {}
 
#ifndef SIP_RUN

    QgsIntRange( int lower = std::numeric_limits< int >::lowest(), int upper = std::numeric_limits< int >::max(), bool includeLower = true, bool includeUpper = true )
      : QgsRange( lower, upper, includeLower, includeUpper )
    {}
#else

    QgsIntRange( int lower, int upper, bool includeLower = true, bool includeUpper = true )
      : QgsRange( lower, upper, includeLower, includeUpper )
    {}

    QgsIntRange()
      : QgsRange( std::numeric_limits< int >::lowest(), std::numeric_limits< int >::max(), true, true )
    {}
#endif

    bool isInfinite() const { return lower() == std::numeric_limits< int >::lowest() && upper() == std::numeric_limits< int >::max(); }
 
#ifdef SIP_RUN
    // clang-format off
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = u"<QgsIntRange: %1%2, %3%4>"_s.arg( sipCpp->includeLower() ? u"["_s : u"("_s )
                  .arg( sipCpp->lower() )
                  .arg( sipCpp->upper() )
                  .arg( sipCpp->includeUpper() ? u"]"_s : u")"_s );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
// clang-format on
#endif
};
 
Q_DECLARE_METATYPE( QgsIntRange )
 
 

template<typename T> class QgsTemporalRange
{
  public:
#ifndef SIP_RUN
    QgsTemporalRange( const T &begin = T(), const T &end = T(), bool includeBeginning = true, bool includeEnd = true )
      : mLower( begin )
      , mUpper( end )
      , mIncludeLower( includeBeginning )
      , mIncludeUpper( includeEnd )
    {}
#else
    QgsTemporalRange( const T &begin, const T &end, bool includeBeginning = true, bool includeEnd = true );
    // default constructor as default value for templates is not handled in SIP
#endif

    T begin() const { return mLower; }

    T end() const { return mUpper; }

    bool includeBeginning() const { return mIncludeLower; }

    bool includeEnd() const { return mIncludeUpper; }

    bool isInstant() const { return mLower.isValid() && mUpper.isValid() && mLower == mUpper && ( mIncludeLower || mIncludeUpper ); }

    bool isInfinite() const { return !mLower.isValid() && !mUpper.isValid(); }

    bool isEmpty() const
    {
      if ( !mLower.isValid() && !mUpper.isValid() )
        return false;
 
      if ( mLower.isValid() != mUpper.isValid() )
        return false;
 
      if ( mLower > mUpper )
        return true;
 
      if ( mLower == mUpper && !( mIncludeLower || mIncludeUpper ) )
        return true;
 
      return false;
    }

    bool contains( const QgsTemporalRange<T> &other ) const
    {
      if ( !other.mLower.isValid() && mLower.isValid() )
        return false;
 
      if ( mLower.isValid() )
      {
        const bool lowerOk = ( mIncludeLower && mLower <= other.mLower ) || ( !mIncludeLower && mLower < other.mLower ) || ( !mIncludeLower && !other.mIncludeLower && mLower <= other.mLower );
        if ( !lowerOk )
          return false;
      }
 
      if ( !other.mUpper.isValid() && mUpper.isValid() )
        return false;
 
      if ( mUpper.isValid() )
      {
        const bool upperOk = ( mIncludeUpper && mUpper >= other.mUpper ) || ( !mIncludeUpper && mUpper > other.mUpper ) || ( !mIncludeUpper && !other.mIncludeUpper && mUpper >= other.mUpper );
        if ( !upperOk )
          return false;
      }
 
      return true;
    }

    bool contains( const T &element ) const
    {
      if ( !element.isValid() )
        return false;
 
      if ( mLower.isValid() )
      {
        const bool lowerOk = ( mIncludeLower && mLower <= element ) || ( !mIncludeLower && mLower < element );
        if ( !lowerOk )
          return false;
      }
 
      if ( mUpper.isValid() )
      {
        const bool upperOk = ( mIncludeUpper && mUpper >= element ) || ( !mIncludeUpper && mUpper > element );
        if ( !upperOk )
          return false;
      }
 
      return true;
    }

    bool overlaps( const QgsTemporalRange<T> &other ) const
    {
      // one or both range is infinite
      if ( isInfinite() || other.isInfinite() )
        return true;
 
      // all bounds are fixed
      if ( mLower.isValid() && mUpper.isValid() && other.mLower.isValid() && other.mUpper.isValid() )
      {
        // other range is completely before or completely after self range
        if ( other.mUpper < mLower || other.mLower > mUpper )
          return false;
 
        // other overlaps self for sure
        if ( other.mUpper > mLower && other.mLower < mUpper )
          return true;
      }
 
      // other is just before and has a bound in common
      if ( other.mUpper == mLower && mLower.isValid() )
        return other.mIncludeUpper && mIncludeLower;
 
      // other is just after and has a bound in common
      if ( other.mLower == mUpper && mUpper.isValid() )
        return other.mIncludeLower && mIncludeUpper;
 
      if ( !mLower.isValid() )
        return other.mLower < mUpper || !other.mLower.isValid();
 
      if ( !mUpper.isValid() )
        return other.mUpper > mLower || !other.mUpper.isValid();
 
      if ( !other.mLower.isValid() )
        return other.mUpper > mLower || !mLower.isValid();
 
      if ( !other.mUpper.isValid() )
        return other.mLower < mUpper || !mUpper.isValid();
 
      // UNREACHABLE CODE
      return false;
    }

    bool extend( const QgsTemporalRange<T> &other )
    {
      if ( other.isEmpty() )
      {
        return false;
      }
      else if ( isEmpty() )
      {
        mLower = other.begin();
        mUpper = other.end();
        mIncludeLower = other.includeBeginning();
        mIncludeUpper = other.includeEnd();
        return true;
      }
 
      // Both not empty, do some math
      bool changed { false };
 
      // Lower
      if ( !other.begin().isValid() || ( begin().isValid() && other.begin() < mLower ) )
      {
        mLower = other.begin();
        mIncludeLower = other.includeBeginning();
        changed = true;
      }
      else if ( other.begin() == mLower && other.includeBeginning() && !mIncludeLower )
      {
        mIncludeLower = true;
        changed = true;
      }
 
      // Upper
      if ( !other.end().isValid() || ( end().isValid() && other.end() > mUpper ) )
      {
        mUpper = other.end();
        mIncludeUpper = other.includeEnd();
        changed = true;
      }
      else if ( other.end() == mUpper && other.includeEnd() && !mIncludeUpper )
      {
        mIncludeUpper = true;
        changed = true;
      }
      return changed;
    }
 
#ifndef SIP_RUN

    static QList< QgsTemporalRange<T> > mergeRanges( const QList< QgsTemporalRange<T> > &ranges )
    {
      if ( ranges.empty() )
        return {};
 
      QList< QgsTemporalRange<T > > sortedRanges = ranges;
      // cppcheck-suppress mismatchingContainerExpression
      std::sort( sortedRanges.begin(), sortedRanges.end(), []( const QgsTemporalRange< T > &a, const QgsTemporalRange< T > &b ) -> bool { return a.begin() < b.begin(); } );
      QList< QgsTemporalRange<T>> res;
      res.reserve( sortedRanges.size() );
 
      QgsTemporalRange<T> prevRange;
      auto it = sortedRanges.constBegin();
      prevRange = *it++;
      for ( ; it != sortedRanges.constEnd(); ++it )
      {
        if ( prevRange.overlaps( *it ) )
        {
          prevRange.extend( *it );
        }
        else
        {
          res << prevRange;
          prevRange = *it;
        }
      }
      res << prevRange;
      return res;
    }
#endif
 
    bool operator==( const QgsTemporalRange<T> &other ) const
    {
      return mLower == other.mLower && mUpper == other.mUpper && mIncludeLower == other.includeBeginning() && mIncludeUpper == other.includeEnd();
    }
 
    bool operator!=( const QgsTemporalRange<T> &other ) const { return ( !operator==( other ) ); }
 
  private:
    T mLower;
    T mUpper;
    bool mIncludeLower = true;
    bool mIncludeUpper = true;
};
 

typedef QgsTemporalRange< QDate > QgsDateRange;
// NOTE -- Python docstrings for QgsDateRange are patched in python/core/__init__.py
 
Q_DECLARE_METATYPE( QgsDateRange )
 

typedef QgsTemporalRange< QDateTime > QgsDateTimeRange SIP_DOC_TEMPLATE;
// NOTE -- Python docstrings for QgsDateTimeRange are patched in python/core/__init__.py
 
Q_DECLARE_METATYPE( QgsDateTimeRange )
 
#endif // QGSRANGE_H