Range.h

#ifndef _theplu_yat_utility_range_
#define _theplu_yat_utility_range_

// $Id: Range.h 3210 2014-05-05 06:10:02Z peter $

/*
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2014 Peter Johansson

  This file is part of the yat library, http://dev.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 3 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include <algorithm>

namespace theplu {
namespace yat {
namespace utility {

  template<typename T>
  class Range
  {
  public:
    typedef T iterator_type;

    // For STL container usage
    Range(void);

    Range(T first, T last);

    T begin(void) const;

    T end(void) const;


    Range& operator=(const Range&);

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

    T first_;
    T last_;
  };

  template<typename T1, typename T2>
  bool operator==(const Range<T1>&, const Range<T2>&);

  template<typename T1, typename T2>
  bool operator!=(const Range<T1>&, const Range<T2>&);

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

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

  template<typename T1, typename T2>
  bool operator>(const Range<T1>&, const Range<T2>&);

  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