STK_Range.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
    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: S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  STKernel::Base
 * Purpose:  Define the Range class.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_RANGE_H
#define STK_RANGE_H
 
#include <map>
 
#if defined(STKBASEARRAYS)
const int firstIdx_ = STKBASEARRAYS;
#else
const int firstIdx_ = 0; // default is 0 based array
#endif
 
 
#define _R(first,last) Range(first, last, 0)
 
namespace STK
{
// forward declaration
template<int Size_> class TRange;
typedef TRange<UnknownSize> Range;
 
template<int Size_>
ostream& operator<< (ostream& s, TRange<Size_> const& I);
 
template<class Derived>
class RangeBase: public IRecursiveTemplate<Derived>
{
  protected:
    inline RangeBase(): begin_(firstIdx_) {}
    inline RangeBase( int begin): begin_(begin) {}
    inline RangeBase( RangeBase const& I): begin_(I.begin_) {}
    template<class OtherDerived>
    inline RangeBase( RangeBase<OtherDerived> const& I): begin_(I.begin()) {}
 
  public:
    inline ~RangeBase() {}
    inline int begin() const { return begin_;};
 
    template<int OtherSize_>
    inline bool isIn(TRange<OtherSize_> const& I) const
    { return ((this->asDerived().begin() >= I.begin()) && (this->asDerived().end() <= I.end()));}
    template<int OtherSize_>
    inline bool isContaining(TRange<OtherSize_> const& I) const
    { return ((begin_<= I.begin())&&(this->asDerived().end()>=I.end()));}
    inline bool isContaining(int i) const { return ((begin_<=i)&&(i<this->asDerived().end()));}
 
    inline Derived& operator+=(int i) { return this->asDerived().inc(i);}
    inline Derived& operator-=(int i) { return this->asDerived().dec(i);}
 
    template<int OtherSize_>
    inline bool operator==(TRange<OtherSize_> const& I) const
    { return ((begin_ == I.begin()) && (this->asDerived().end() == I.end()));}
    template<int OtherSize_>
    inline bool operator!=(TRange<OtherSize_> const& I) const
    { return ((begin_ != I.begin()) || (this->asDerived().end() != I.end()));}
 
 protected:
    int begin_; 
};
 
template<int Size_>
class TRange: public RangeBase< TRange<Size_> >
{
  public:
    typedef RangeBase< TRange<Size_> > Base;
    using Base::begin_;
 
    inline TRange( int size = Size_): Base() {}
    inline TRange( int first, int ): Base(first) {}
    inline TRange( int first, int , bool ): Base(first) {}
    inline TRange(TRange const& I): Base(I) {}
    template<int OtherSize_>
    inline TRange(TRange<OtherSize_> const& I): Base(I) {}
    inline ~TRange() {}
    inline int end() const { return begin_ + Size_;};
    inline int size() const { return Size_;};
    inline bool empty() const { return Size_<=0;};
 
    // backward compatibility
    inline int lastIdx() const { return begin_ + Size_ -1;};
 
    inline TRange& shift(int begin) { begin_= begin; return *this;}
    inline TRange& inc(int inc =1) { begin_ +=inc; return *this;}
    inline TRange& dec(int dec=1) { begin_ -=dec; return *this;}
 
    inline TRange& incFirst(int inc=1) { begin_ +=inc; return *this;}
    inline TRange& decFirst(int dec=1) { begin_ -=dec;  return *this;}
 
    inline TRange& incEnd(int inc =1) { return *this;}
    inline TRange& decEnd(int dec =1){ return *this;}
 
    // backward compatibility
    inline TRange& incLast(int inc =1) { return *this;}
    inline TRange& decLast(int dec =1){ return *this;}
};
 
template<>
class TRange<UnknownSize>: public RangeBase< TRange<UnknownSize> >
{
  public:
    typedef RangeBase<TRange<UnknownSize> > Base;
    using Base::begin_;
 
    inline TRange( int size =0): Base(), size_(size) {}
    inline TRange( int first, int size): Base(first), size_(size) {}
    inline TRange( int first, int last, bool junk): Base(first), size_(last+1-first) {}
    inline TRange(TRange const& I): Base(I), size_(I.size_) {}
    template<int OtherSize_>
    inline TRange(TRange<OtherSize_> const& I): Base(I), size_(I.size()) {}
    inline ~TRange() {}
    inline int end()  const { return begin_+ size_;}
    inline int size()   const { return size_;}
    inline bool empty() const { return size_<=0;}
 
    // backward compatibility
    inline int lastIdx() const { return(end()-1);}
 
    inline TRange& shift(int first) { return inc(first - begin_);}
    inline TRange& inc(int inc =1){ begin_ +=inc; return *this;}
    inline TRange& dec(int dec =1) { begin_ -=dec; return *this;}
    inline TRange& incFirst(int inc =1) { begin_ +=inc; size_ -=inc; return *this;}
    inline TRange& decFirst(int dec =1) { begin_ -=dec; size_ +=dec; return *this;}
 
    inline TRange& incEnd(int inc =1) { size_ +=inc; return *this;}
    inline TRange& decEnd(int dec =1){ size_ -=dec; return *this;}
 
    // backward compatibility
    inline TRange& incLast(int inc =1) { size_ +=inc; return *this;}
    inline TRange& decLast(int dec =1){ size_ -=dec; return *this;}
 
    template<int OtherSize_>
    inline TRange& sup(TRange<OtherSize_> const& I)
    {
      begin_  = std::min(begin_, I.begin());
      size_   = std::max(end(), I.end()) - begin_;
      return *this;
    }
    template<int OtherSize_>
    inline TRange& inf(TRange<OtherSize_> const& I)
    {
      begin_ = std::max(begin_, I.begin());
      size_  = std::min(end(), I.end()) - begin_;
      return *this;
    }
 
    friend istream& operator>> (istream& is, Range& I);
 
  private:
    int size_;     
 
};
 
template<int Size_>
struct Arithmetic< TRange<Size_> >: public std::numeric_limits< TRange<Size_> >
{
  static inline  TRange<Size_> NA() throw()
  { return TRange<Size_>(std::numeric_limits<int>::min(), std::numeric_limits<int>::min(), 0);}
  static const bool hasNA = true;
  static inline bool isNA(TRange<Size_> const& x) throw()
  { return (x.begin() == std::numeric_limits<int>::min());}
  static inline bool isInfinite(TRange<Size_> const& x) throw() { return false; }
  static inline bool isFinite(TRange<Size_> const& x) throw() { return (!isNA(x) && !isInfinite(x));}
};
 
template<int Size_>
struct IdTypeImpl< TRange<Size_> >
{
  static inline Base::IdType returnType() { return(Base::range_);}
};
 
 
inline istream& operator>> (istream& is, Range& I)
{
  String str;
  std::getline(is, str, _T(':'));
  // get first number
  if (!stringToType(I.begin_, str))
  {
    I = Arithmetic<Range>::NA();
    is.clear(); is.setstate(std::ios::failbit);
    return is;
  }
  // check if the istream is exhausted
  if (is.eof())
  {
    I.size_ = 1;
    return is;
  }
  // skip the current char ":"
  is.peek();
  // get second number
  if ((is >> I.size_).fail())
  {
    I = Arithmetic<Range>::NA();
    is.clear(); is.setstate(std::ios::failbit);
    return is;
  }
  else { I.size_ -= I.begin_ ;}
  return is;
}
 
template<int SizeI_, int SizeJ_>
Range sup(TRange<SizeI_> const& I, TRange<SizeJ_> const& J)
{ return Range(std::min(I.begin(), J.begin()), std::max(I.lastIdx(), J.lastIdx()), 0);}
template<int SizeI_, int SizeJ_>
Range inf(TRange<SizeI_> const& I, TRange<SizeJ_> const& J)
{ return Range(std::max(I.begin(), J.begin()), std::min(I.lastIdx(), J.lastIdx()), 0);}
template<int SizeI_>
Range incFirst(TRange<SizeI_> const& I)
{ return Range(I.begin()+1, I.lastIdx(), 0);}
template<int SizeI_>
Range incLast(TRange<SizeI_> const& I)
{ return Range(I.begin(), I.lastIdx()+1, 0);}
template<int SizeI_>
Range decFirst(TRange<SizeI_> const& I)
{ return Range(I.begin()-1, I.lastIdx(), 0);}
template<int SizeI_>
Range decLast(TRange<SizeI_> const& I)
{ return Range(I.begin(), I.lastIdx()-1, 0);}
 
template<int Size_>
ostream& operator<< (ostream& os, TRange<Size_> const& I)
{
  (Arithmetic< TRange<Size_> >::isNA(I)) ? os <<  stringNa
                                         : os <<  I.begin() << _T(":") << I.lastIdx();
  return os;
}
 
inline Range stringToRange( String const& str)
{ return stringToType<Range>(str);}
 
template<int Size_>
TRange<Size_> stringToRange( String const& str, std::map<String, TRange<Size_> > const& mapping)
{
  typename std::map<String, TRange<Size_> >::const_iterator it=mapping.find(str);
  return (it == mapping.end()) ? Arithmetic< TRange<Size_> >::NA() : it->second;
}
 
template<int Size_>
String rangeToString( TRange<Size_> const& value, std::ios_base& (*f)(std::ios_base&) = std::dec)
{
  if (Arithmetic<TRange<Size_> >::isNA(value)) return stringNa;
  ostringstream os;
  os << f << value;
  return os.str();
}
 
template<int Size_>
String rangeToString( TRange<Size_> const& value, std::map<TRange<Size_> , String> const& mapping)
{
  typename std::map<TRange<Size_> , String>::const_iterator it=mapping.find(value);
  if (it == mapping.end())  return stringNa;
  return it->second;
}
 
template<>
inline String typeToString<Range >( Range const& t, std::ios_base& (*f)(std::ios_base&))
{ return rangeToString(t, f);}
 
 
} // namespace STK
 
#endif // STK_RANGE_H