range.h

Go to the documentation of this file.

/*
    This file is part of the Okteta Core library, made within the KDE community.

    Copyright 2003,2007-2008 Friedrich W. H. Kossebau <kossebau@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) version 3, or any
    later version accepted by the membership of KDE e.V. (or its
    successor approved by the membership of KDE e.V.), which shall
    act as a proxy defined in Section 6 of version 3 of the license.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef KDE_RANGE_H
#define KDE_RANGE_H


namespace KDE
{

template<typename T>
class Range
{
  public:
    Range( T S, T E ) : Start( S ), End( E )  {}
    Range() : Start( null() ), End( null() )  {}
    ~Range() {}

  public:
    Range &operator=( const Range &R ) { Start = R.Start; End = R.End; return *this; }

  public:
    bool operator==( const Range &R ) const
         { return (Start == R.Start && End == R.End) || (!isValid() && !R.isValid()); }

  public: // modification access
    void set( T S, T E ) { Start = S; End = E; }
    void set( const Range &R ) { Start = R.Start; End = R.End; }
    void setStart( T S )  { Start = S; }
    void setEnd( T E )    { End = E; }
    void unset()           { Start = End = null(); }
    void restrictTo( const Range &Limit )
    { if( Start < Limit.start() ) Start = Limit.start(); if( End > Limit.end() ) End = Limit.end(); }
    void restrictStartTo( T Limit )  { if( Start < Limit ) Start = Limit; }
    void restrictEndTo( T Limit )    { if( End > Limit ) End = Limit; }
    void extendTo( const Range &Limit )
    { if( Start > Limit.start() ) Start = Limit.start(); if( End < Limit.end() ) End = Limit.end(); }
    void extendStartTo( T Limit )  { if( Start > Limit ) Start = Limit; }
    void extendEndTo( T Limit )    { if( End < Limit ) End = Limit; }
    void moveStartBy( T D )  { Start += D; }
    void moveEndBy( T D )    { End += D; }
    void moveBy( T D )      { Start += D; End += D; }

  public: // value access
    T start() const { return Start; }
    T end() const   { return End; }


  public: // logic access
    bool includes( T Value )     const { return Start <= Value && Value <= End; }
    bool includesInside( T Value )     const { return Start < Value && Value < End; }
    bool startsBehind( T Value ) const { return Value < Start; }
    bool startsBefore( T Value ) const { return Start < Value; }
    bool endsBehind( T Value )   const { return Value < End; }
    bool endsBefore( T Value )   const { return End < Value; }

    bool includes( const Range &R )     const { return R.End <= End && Start <= R.Start; }
    bool includesInside( const Range &R ) const { return R.End < End && Start < R.Start; }
    bool endsBefore( const Range &R )   const { return End < R.Start; }
    bool startsBehind( const Range &R ) const { return R.End < Start; }
    bool startsBefore( const Range &R ) const { return Start < R.Start; }
    bool endsBehind( const Range &R )   const { return R.End < End; }
    bool overlaps( const Range &R ) const { return Start <= R.End && R.Start <= End; }

    // TODO: this is wrong, a empty range is valid, too
    bool isValid() const { return Start != null() && Start <= End; }
    bool isEmpty() const { return Start == null() && End == null(); }


  protected:
    const T null () const { return T(-1);}

  protected:
    T Start;
    T End;
};

}

#endif