STK_Range.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2009  Serge Iovleff

    This program 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 of the
    License, or (at your option) any later version.

    This program 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 program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA

    Contact : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  stkpp::STKernel::Base
 * Purpose:  Define the Range class.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_RANGE_H
#define STK_RANGE_H

#include "STK_Integer.h"
#include "STK_Stream.h"

namespace STK
{
class Range
{
  private:
    Integer first_;    
    Integer last_;     
    Integer size_;     

  public:
    Range(Integer const& last =0);

    Range(Integer const& first, Integer const& last);

    Range(Range const& I);

     ~Range();

    inline Integer const& first()  const { return first_;};
    inline Integer const& last()    const { return last_;};
    inline Integer const& size()   const { return size_;};
    inline bool    empty() const { return size_<=0;};
    inline bool isIn(Range const& I) const
    { return ((first_>= I.first_)&&(last_<=I.last_));}
    inline bool isContaining(Range const& I) const
    { return ((first_<= I.first_)&&(last_>=I.last_));}
    inline bool isContaining(Integer const& i) const
    { return ((first_<=i)&&(last_>=i));}
    inline bool operator==(Range const& I) const
    { return ((first_ == I.first()) && (last_ == I.last()));}
    inline bool operator!=(Range const& I) const
    { return ((first_ != I.first()) || (last_ != I.last()));}

    Range& set(Integer const& first =1, Integer const& last =0);
    Range& shift(Integer const& first =1);
    Range& inc(Integer const& inc =1);
    Range& incFirst(Integer const& inc =1);
    Range& incLast(Integer const& inc =1);
    Range& dec(Integer const& dec =1);
    Range& decFirst(Integer const& dec =1);
    Range& decLast(Integer const& dec =1);
    Range& sup(Range const& I);
    Range& inf(Range const& I);
    Range& operator+=(Integer const& inc);
    Range& operator-=(Integer const& dec);

    Range plus(Integer const& inc =1);
    Range minus(Integer const& dec =1);

    static Range sup(Range const& I, Range const& J);
    static Range inf(Range const& I, Range const& J);
    friend ostream& operator<< (ostream& s, Range const& I);
    friend istream& operator>> (istream& s, Range& I);
};

Range operator-(Range const& I, Integer const& dec);

Range operator+(Range const& I, Integer const& inc);

} // Namespace STK

#endif // STK_RANGE_H