Range.h

Go to the documentation of this file.

#ifndef RANGE_H
#define RANGE_H

#include <algorithm>
#include <functional>
#include <stdexcept>
#include <utility>

namespace util {

  template <class T>
  class UniqueRangeSet;

  template <class T>
  class Range {
    // Make it a friend so UniqueRangeSet can access protected guys
    friend class UniqueRangeSet<T>;

  private:
    Range() {}

  public:
    Range(const T& start, const T& end) : _window(start, end)
    {
      if (start > end) throw std::runtime_error("Inserted invalid range: end before start.");
    }

    ~Range() {}

    const T& Start() const { return _window.first; }
    const T& End() const { return _window.second; }
    void Set(const T& s, const T& e)
    {
      if (s >= e) throw std::runtime_error("Inserted invalid range: end before start.");
      _window.first = s;
      _window.second = e;
    }

    //
    // Ordering w/ another Range
    //
    inline bool operator<(const Range& rhs) const { return (_window.second < rhs.Start()); }
    inline bool operator>(const Range& rhs) const { return (_window.first > rhs.End()); }
    inline bool operator==(const Range& rhs) const
    {
      return (_window.first == rhs.Start() && _window.second == rhs.End());
    }
    inline bool operator!=(const Range& rhs) const { return !((*this) == rhs); }

    //
    // Ordering w/ T
    //
    inline bool operator<(const T& rhs) const { return (_window.second < rhs); }
    inline bool operator>(const T& rhs) const { return (_window.first > rhs); }

    void Merge(const Range& a)
    {
      _window.first = std::min(_window.first, a.Start());
      _window.second = std::max(_window.second, a.End());
    }

  protected:
    std::pair<T, T> _window;
  };
}

namespace std {
  // Implement pointer comparison in case it's useful
  template <class T>
  class less<util::Range<T>*> {
  public:
    bool operator()(const util::Range<T>* lhs, const util::Range<T>* rhs)
    {
      return (*lhs) < (*rhs);
    }
  };
}

#endif
 // end of doxygen group