source: trunk/yat/utility/Range.h @ 1340

#ifndef _theplu_yat_utility_range_
#define _theplu_yat_utility_range_

// $Id: Range.h 1340 2008-06-12 18:51:53Z peter $

/*
  Copyright (C) 2008 Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/yat

  The yat library 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.

  The yat 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
  General Public License for more details.

  You should have received a copy of the GNU 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.
*/

#include <algorithm>

namespace theplu {
namespace yat {
namespace utility {

  /**
     @brief A class for storing a shallow copy of a Range

     This class can be used to create a shallow copy of range, [first,
     end), defined by two iterators of type T. This can be useful, for
     example, when creating numerous sub-ranges of a larger container.

     \since New in yat 0.5
  */
  template<typename T>
  class Range
  {
  public:
    /**
       @brief Default Constructor 
    */
    // For STL container usage
    Range(void);

    /**
       @brief Constructor 
    */
    Range(T first, T last);

    /**
       \note If T is a mutable iterator, it is possible to use
       returned iterator to modify underlying range although this
       function is const.

       \return iterator indicating beginning of Range.
     */
    T begin(void) const;

    /**
       \return iterator after the Range.
     */
    T end(void) const;


    /**
       @brief Does not modify underlying data.

       This only changes this object by reassigning two iterators,
       begin() and end(). If you would like to modify the underlying
       data, use std::copy instead.
    */
    Range& operator=(const Range&);

  private:
    // Using compiler generated copy constructor
    // Range(const Range&);

    T first_;
    T last_;
  };

  /**
     \brief Equality comparison
     \return true iff underlying elements are equal

     \since New in yat 0.5
   */  
  template<typename T1, typename T2>
  bool operator==(const Range<T1>&, const Range<T2>&);

  /**
     \brief Based on operator==

     \since New in yat 0.5
   */  
  template<typename T1, typename T2>
  bool operator!=(const Range<T1>&, const Range<T2>&);

  /**
     \brief Ordering relation

     Using std::lexicographical_compare

     \return true if \a lhs < \a rhs

     \since New in yat 0.5
   */  
  template<typename T1, typename T2>
  bool operator<(const Range<T1>& lhs, const Range<T2>& rhs);

  /**
     \return ! (\a rhs < \a lhs )

     \since New in yat 0.5
   */  
  template<typename T1, typename T2>
  bool operator<=(const Range<T1>& lhs, const Range<T2>& rhs);

  /**
     \return \a rhs < \a lhs

     \since New in yat 0.5
   */  
  template<typename T1, typename T2>
  bool operator>(const Range<T1>&, const Range<T2>&);

  /**
     \return ! (\a lhs < \a rhs )

     \since New in yat 0.5
   */  
  template<typename T1, typename T2>
  bool operator>=(const Range<T1>&, const Range<T2>&);


  // implementations
  template<typename T>
  Range<T>::Range(void){}
    
  template<typename T>
  Range<T>::Range(T first, T last)
    : first_(first), last_(last)
  {}
  
  template<typename T>
  T Range<T>::begin(void) const
  { return first_; }
    

  template<typename T>
  T Range<T>::end(void) const
  { return last_; }
    

  template<typename T>
  Range<T>& Range<T>::operator=(const Range<T>& rhs)
  {
    first_ = rhs.begin();
    last_ = rhs.end();
    return *this;
  }


  template<typename T1, typename T2>
  bool operator==(const Range<T1>& lhs, const Range<T2>& rhs)
  {
    // we are not using std::equal because we want to handle ranges of
    // different length
    T1 first1(lhs.begin());
    T1 last1(lhs.end());
    T2 first2(rhs.begin());
    T2 last2(rhs.end());
    while (first1 != last1 && first2 != last2) {
      if (*first1 != *first2)
        return false;
      ++first1;
      ++first2;
    }
    // check that ranges are equally long
    return first1==last1 && first2==last2;
  }


  template<typename T1, typename T2>
  bool operator!=(const Range<T1>& lhs, const Range<T2>& rhs)
  { 
    return ! (lhs==rhs); 
  }


  template<typename T1, typename T2>
  bool operator<(const Range<T1>& lhs, const Range<T2>& rhs)
  { 
    return std::lexicographical_compare(lhs.begin(), lhs.end(),
                                        rhs.begin(), rhs.end()); 
  }


  template<typename T1, typename T2>
  bool operator>(const Range<T1>& lhs, const Range<T2>& rhs)
  { 
    return rhs < lhs; 
  }


  template<typename T1, typename T2>
  bool operator<=(const Range<T1>& lhs, const Range<T2>& rhs)
  { 
    return ! (rhs<lhs); 
  }


  template<typename T1, typename T2>
  bool operator>=(const Range<T1>& lhs, const Range<T2>& rhs)
  { 
    return ! (lhs<rhs); 
  }

}}} // of namespace utility, yat, and theplu

#endif