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_sip.h"
#include "qgis_core.h"
#include "qgis.h"

#include <QDate>
#include <QDateTime>

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 )
    {}

    T lower() const { return mLower; }

    T upper() const { return mUpper; }

    bool includeLower() const { return mIncludeLower; }

    bool includeUpper() const { return mIncludeUpper; }

    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
    {
      bool lowerOk = ( mIncludeLower && mLower <= other.mLower )
                     || ( !mIncludeLower && mLower < other.mLower )
                     || ( !mIncludeLower && !other.mIncludeLower && mLower <= other.mLower );
      if ( !lowerOk )
        return false;

      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
    {
      bool lowerOk = ( mIncludeLower && mLower <= element )
                     || ( !mIncludeLower && mLower < element );
      if ( !lowerOk )
        return false;

      bool upperOk = ( mIncludeUpper && mUpper >= element )
                     || ( !mIncludeUpper && mUpper > element );
      if ( !upperOk )
        return false;

      return true;
    }

    bool overlaps( const QgsRange<T> &other ) const
    {
      if ( ( ( mIncludeLower && mLower <= other.mLower ) || ( !mIncludeLower && mLower < other.mLower ) )
           && ( ( mIncludeUpper  && mUpper >= other.mUpper ) || ( !mIncludeUpper && mUpper > other.mUpper ) ) )
        return true;

      if ( ( ( mIncludeLower && mLower <= other.mLower ) || ( !mIncludeLower && mLower < other.mLower ) )
           && ( ( mIncludeUpper  && mUpper >= other.mLower ) || ( !mIncludeUpper && mUpper > other.mLower ) ) )
        return true;

      if ( ( ( mIncludeLower && mLower <= other.mUpper ) || ( !mIncludeLower && mLower < other.mUpper ) )
           && ( ( mIncludeUpper && mUpper >= other.mUpper ) || ( !mIncludeUpper && mUpper > other.mUpper ) ) )
        return true;

      if ( ( ( mIncludeLower && mLower >= other.mLower ) || ( !mIncludeLower && mLower > other.mLower ) )
           && ( ( mIncludeLower && mLower <= other.mUpper ) || ( !mIncludeLower && mLower < other.mUpper ) ) )
        return true;

      if ( mLower == other.mLower && mUpper == other.mUpper )
        return true;

      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;

};


class CORE_EXPORT QgsDoubleRange : public QgsRange< double >
{
  public:

#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
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsDoubleRange: %1%2, %3%4>" ).arg( sipCpp->includeLower() ? QStringLiteral( "[" ) : QStringLiteral( "(" ) )
                  .arg( sipCpp->lower() )
                  .arg( sipCpp->upper() )
                  .arg( sipCpp->includeUpper() ? QStringLiteral( "]" ) : QStringLiteral( ")" ) );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#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 ) );
    }

};


class CORE_EXPORT QgsIntRange : public QgsRange< int >
{
  public:

#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
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsIntRange: %1%2, %3%4>" ).arg( sipCpp->includeLower() ? QStringLiteral( "[" ) : QStringLiteral( "(" ) )
                  .arg( sipCpp->lower() )
                  .arg( sipCpp->upper() )
                  .arg( sipCpp->includeUpper() ? QStringLiteral( "]" ) : QStringLiteral( ")" ) );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

};


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() )
      {
        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() )
      {
        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() )
      {
        bool lowerOk = ( mIncludeLower && mLower <= element )
                       || ( !mIncludeLower && mLower < element );
        if ( !lowerOk )
          return false;
      }

      if ( mUpper.isValid() )
      {
        bool upperOk = ( mIncludeUpper && mUpper >= element )
                       || ( !mIncludeUpper && mUpper > element );
        if ( !upperOk )
          return false;
      }

      return true;
    }

    bool overlaps( const QgsTemporalRange<T> &other ) const
    {
      if ( !mUpper.isValid() && ( ( mIncludeLower && mLower <= other.mUpper ) || ( !mIncludeLower && mLower < other.mUpper ) ) )
        return true;

      if ( ( ( mIncludeLower && mLower <= other.mLower ) || ( !mIncludeLower && mLower < other.mLower ) )
           && ( ( mIncludeUpper  && mUpper >= other.mUpper ) || ( !mIncludeUpper && mUpper > other.mUpper ) ) )
        return true;

      if ( ( ( mIncludeLower && mLower <= other.mLower ) || ( !mIncludeLower && mLower < other.mLower ) )
           && ( ( mIncludeUpper  && mUpper >= other.mLower ) || ( !mIncludeUpper && mUpper > other.mLower ) ) )
        return true;

      if ( ( ( mIncludeLower && mLower <= other.mUpper ) || ( !mIncludeLower && mLower < other.mUpper ) )
           && ( ( mIncludeUpper && mUpper >= other.mUpper ) || ( !mIncludeUpper && mUpper > other.mUpper ) ) )
        return true;

      if ( ( ( mIncludeLower && mLower >= other.mLower ) || ( !mIncludeLower && mLower > other.mLower ) )
           && ( ( mIncludeLower && mLower <= other.mUpper ) || ( !mIncludeLower && mLower < other.mUpper ) ) )
        return true;

      if ( mLower == other.mLower && mUpper == other.mUpper )
        return true;

      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;
    }

    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 SIP_DOC_TEMPLATE;

typedef QgsTemporalRange< QDateTime > QgsDateTimeRange SIP_DOC_TEMPLATE;

#endif // QGSRANGE_H