source: trunk/yat/utility/Segment.h @ 2321

#ifndef theplu_yat_utility_segment
#define theplu_yat_utility_segment

// $Id: Segment.h 2321 2010-09-02 22:40:08Z peter $

/*
  Copyright (C) 2010 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>
#include <functional>

namespace theplu {
namespace yat {
namespace utility {

  /**
     \brief a class for a Segment or Interval

     A class for a Segment [begin, end). 

     \since new in yat 0.7
   */
  template<typename T, class Compare = std::less<T> >
  class Segment
  {
  public:
    /**
       type the Segment holds
     */
    typedef T value_type;

    /**
       \brief default constructor
     */
    Segment(void) {}

    /**
       \brief Constructor

       Creates a segment [begin, end)
     */
    Segment(const T& begin, const T& end)
      : begin_(begin), end_(end) {}

    /**
       \return reference to first element in Segment
     */
    T& begin(void) { return begin_; }

    /**
       \return const reference to first element in Segment
     */
    const T& begin(void) const { return begin_; }

    /**
       \return reference to first element greater than Segment
     */
    T& end(void) { return end_; }

    /**
       \return const reference to first element greater than Segment
     */
    const T& end(void) const { return end_; }
    
  private:
    T begin_;
    T end_;
    
    // using compiler generated copying
    //Segment(const Segment&);
    //Segment& operator=(const Segment&);
  };

  /**
     \return true if all elements in \a lhs is less than all elements
     in \a rhs, i.e., returns false if rhs.begin() is less than
     lhs.end()

     \relates Segment

     \since new in yat 0.7
   */
  template<typename T, class Compare>
  bool compare(const Segment<T, Compare>& lhs, const Segment<T, Compare>& rhs)
  {
    Compare c;
    return ! c(rhs.begin(), lhs.end());
  }

  /**
     \return -1 if all elements in lhs is less than all elements in
     rhs; +1 if all elements in rhs is less than all elements in lhs;
     and 0 if lhs and rhs overlap.

     \relates Segment

     \since new in yat 0.7
   */
  template<typename T, class Compare>
  int compare_3way(const Segment<T, Compare>& lhs, 
                    const Segment<T, Compare>& rhs)
  {
    if (compare(lhs, rhs))
      return -1;
    if (compare(rhs, lhs))
      return 1;
    return 0;
  }

  /**
     \return -1 if lhs is less than all elements in rhs; +1 if all
     elements in rhs is less than lhs; and 0 if lhs and rhs overlap

     \relates Segment

     \since new in yat 0.7
   */
  template<typename T, class Compare>
  int compare_3way(const T& lhs, 
                   const Segment<T, Compare>& rhs)
  {
    Compare comp;
    if (comp(lhs, rhs.begin()))
      return -1;
    if (comp(lhs, rhs.end()))
      return 0;
    return 1;
  }

  /**
     \return intersection of \a a and \a b. If \a a and \b do not
     overlap an empty Section is returned (begin==end), but the exact
     value of begin is undefined.

     \relates Segment

     \since new in yat 0.7
   */
  template<typename T, class Compare>
  Segment<T, Compare> intersection(const Segment<T, Compare>& a, 
                                   const Segment<T, Compare>& b)
  {
    Compare comp;
    Segment<T, Compare> result;

    result.begin() = std::max(a.begin(), b.begin(), comp);
    result.end() = std::max(result.begin(), 
                            std::min(a.end(), b.end(), comp),
                            comp);
    return result;
  }

}}}
#endif