STK_Inx.cpp

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
*/
/*--------------------------------------------------------------------*/
/* $Id$
 *
 * Project:  Tcontainer
 * Purpose:  implement the Inx class.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 * $Log$
 * Revision 1.4  2009/09/14 13:33:38  siovleff
 * Refactoring Contant strings
 *
 **/
/*--------------------------------------------------------------------*/
#include "../include/STK_Inx.h"
#include "../include/STK_Misc.h"

namespace STK
{

Inx::Inx( const Integer& last)
        : first_(1)
        , last_(last)
        , size_(last)
{ ;}

Inx::Inx( const Integer& first, const Integer& last)
        : first_(first)
        , last_(last)
        , size_(last-first+1)
{ ;}


Inx::Inx( const Inx &I)
        : first_(I.first())
        , last_(I.last())
        , size_(I.size())
{ ;}

Inx::~Inx() { ;}

/*--------------------------------------------------------------------*/
/* Manipulation of the index.                                         */
Inx& Inx::set(const Integer& first, const Integer& last)
{
  first_ = first;
  last_  = last;
  size_     = last - first + 1;
  return *this;
}

Inx& Inx::shift(const Integer& first)
{
  return inc(first - first_); // use the inc method
}

Inx& Inx::inc(const Integer& inc)
{
  first_ +=inc;
  last_  +=inc;
  return *this;
}
Inx& Inx::incFirst(const Integer& inc)
{
  first_ +=inc;
  size_     -=inc;
  return *this;
}
Inx& Inx::incLast(const Integer& inc)
{
  last_ +=inc;
  size_    +=inc;
  return *this;
}

Inx& Inx::dec(const Integer& dec)
{
  first_ -=dec;
  last_  -=dec;
  return *this;
}
Inx& Inx::decFirst(const Integer& dec)
{
  first_ -=dec;
  size_     +=dec;
  return *this;
}
Inx& Inx::decLast(const Integer& dec)
{
  last_ -=dec;
  size_    -=dec;
  return *this;
}

Inx& Inx::sup(const Inx& I)
{
  first_ = min(first_, I.first_);
  last_  = max(last_, I.last_);
  size_     = last_ - first_ +1;
  return *this;
}

Inx& Inx::inf(const Inx& I)
{
  first_ = max(first_, I.first_);
  last_  = min(last_, I.last_);
  size_     = last_ - first_ +1;
  return *this;
}
Inx Inx::sup(const Inx& I, const Inx& J)
{
  return Inx(min(I.first_, J.first_), max(I.last_, J.last_));
}

Inx Inx::inf(const Inx& I, const Inx& J)
{
  return Inx(max(I.first_, J.first_), min(I.last_, J.last_));
}

/*--------------------------------------------------------------------*/
/* Ops on the class Inx.                                              */
Inx& Inx::operator+=(const Integer& inc)
{ first_ += inc; last_ += inc; return *this;}

Inx& Inx::operator-=(const Integer& dec)
{ first_ -= dec; last_ -= dec; return *this;}

 Inx Inx::operator+(const Integer& inc) const
{return Inx(first_+inc, last_+inc);}

Inx Inx::operator-(const Integer& dec) const
{return Inx(first_-dec, last_-dec);}

ostream& operator<< (ostream& s, const Inx& I)
{
  s << I.first_ << ":" << I.last_;
  return s;
}

} // Namespace STK