// Copyright 2002 The Trustees of Indiana University.

// Use, modification and distribution is subject to the Boost Software 

// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

//  Boost.MultiArray Library

//  Authors: Ronald Garcia

//           Jeremy Siek

//           Andrew Lumsdaine

//  See http://www.boost.org/libs/multi_array for documentation.

#ifndef BOOST_INDEX_RANGE_RG071801_HPP

#define BOOST_INDEX_RANGE_RG071801_HPP

#include <boost/config.hpp>

#include <utility>

#include <boost/limits.hpp>

// For representing intervals, also with stride.

// A degenerate range is a range with one element.

// Thanks to Doug Gregor for the really cool idea of using the

// comparison operators to express various interval types!

// Internally, we represent the interval as half-open.

namespace boost {

namespace detail {

namespace multi_array {

  template <typename Index,typename SizeType>

  class index_range {

  public:

    typedef Index index;

    typedef SizeType size_type;

  private:

    static index from_start()

      { return (std::numeric_limits<index>::min)(); }

    static index to_end()

      { return (std::numeric_limits<index>::max)(); }

  public:

    index_range()

    {

      start_ = from_start();

      finish_ = to_end();

      stride_ = 1;

      degenerate_ = false;

    }

    explicit index_range(index pos)

    {

      start_ = pos;

      finish_ = pos+1;

      stride_ = 1;

      degenerate_ = true;

    }

    explicit index_range(index start, index finish, index stride=1)

      : start_(start), finish_(finish), stride_(stride),

        degenerate_(false)

    { }

    // These are for chaining assignments to an index_range

    index_range& start(index s) {

      start_ = s;

      degenerate_ = false;

      return *this;

    }

    index_range& finish(index f) {

      finish_ = f;

      degenerate_ = false;

      return *this;

    }

    index_range& stride(index s) { stride_ = s; return *this; }

    index start() const

    { 

      return start_; 

    }

    index get_start(index low_index_range = index_range::from_start()) const

    { 

      if (start_ == from_start())

        return low_index_range;

      return start_; 

    }

    index finish() const

    {

      return finish_;

    }

    index get_finish(index high_index_range = index_range::to_end()) const

    {

      if (finish_ == to_end())

        return high_index_range;

      return finish_;

    }

    index stride() const { return stride_; }

    void set_index_range(index start, index finish, index stride=1)

    {

      start_ = start;

      finish_ = finish;

      stride_ = stride;

    }

    static index_range all() 

    { return index_range(from_start(), to_end(), 1); }

    bool is_degenerate() const { return degenerate_; }

    index_range operator-(index shift) const

    { 

      return index_range(start_ - shift, finish_ - shift, stride_); 

    }

    index_range operator+(index shift) const

    { 

      return index_range(start_ + shift, finish_ + shift, stride_); 

    }

    index operator[](unsigned i) const

    {

      return start_ + i * stride_;

    }

    index operator()(unsigned i) const

    {

      return start_ + i * stride_;

    }

    // add conversion to std::slice?

  public:

    index start_, finish_, stride_;

    bool degenerate_;

  };

  // Express open and closed interval end-points using the comparison

  // operators.

  // left closed

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<=(Index s, const index_range<Index,SizeType>& r)

  {

    return index_range<Index,SizeType>(s, r.finish(), r.stride());

  }

  // left open

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<(Index s, const index_range<Index,SizeType>& r)

  {

    return index_range<Index,SizeType>(s + 1, r.finish(), r.stride());

  }

  // right open

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<(const index_range<Index,SizeType>& r, Index f)

  {

    return index_range<Index,SizeType>(r.start(), f, r.stride());

  }

  // right closed

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<=(const index_range<Index,SizeType>& r, Index f)

  {

    return index_range<Index,SizeType>(r.start(), f + 1, r.stride());

  }

} // namespace multi_array

} // namespace detail  

} // namespace boost

#endif // BOOST_INDEX_RANGE_RG071801_HPP