#include <iostream>
#include <tuple>

using namespace std;

typedef tuple<int, int, int> Tuple;
int const Num = tuple_size<Tuple>::value;

template <typename T1, typename T2>
ostream& operator<<(ostream& os, tuple<T1,T2> const& t) {
  return os << "{" << get<0>(t) << "," << get<1>(t) << "}";
}

template <typename T1, typename T2, typename T3>
ostream& operator<<(ostream& os, tuple<T1,T2,T3> const& t) {
  return os << "{" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << "}";
}

// odo short for odometer.
template<size_t N>
struct odo_right_to_left {
  template<typename... Iters>
  static void apply(tuple<Iters...>& i,
                    tuple<Iters...> const& b,
                    tuple<Iters...> const& e)
  {
    // Only increment when you're non-empty.
    if(get<N>(i) == get<N>(e)) {
      // TODO: If the range in N (b, e] is guaranteed to be non-empty, then we
      // can omit this check.
      odo_right_to_left<N - 1>::apply(i, b, e);
    } else {
      // Incrementing the current element. If the increment pushes this past
      // the end, then increment the previous (next lower) iterator.
      ++get<N>(i);
      if(get<N>(i) == get<N>(e)) {
        get<N>(i) = get<N>(b);
        odo_right_to_left<N - 1>::apply(i, b, e);
      }
    }
  }
};

template<>
struct odo_right_to_left<0> {
  template<typename... Iters>
  static void apply(tuple<Iters...>& i,
                    tuple<Iters...> const& b,
                    tuple<Iters...> const& e)
  {
    if(get<0>(i) == get<0>(e)) {
      // If the last position is invalid, then we should probably need to
      // invalidate the entire odometer.
      i = e;
    } else {
      // As before, but if we reach the end in the outermost iterator, reset the
      // entire tuple to be equal to end.
      ++get<0>(i);
      if(get<0>(i) == get<0>(e)) {
        i = e;
      }
    }
  }
};

template<typename... Iters>
void incr_right_to_left(tuple<Iters...>& i, tuple<Iters...> const& b, tuple<Iters...> const& e) {
  odo_right_to_left<sizeof...(Iters) - 1>::apply(i, b, e);
}


// odo short for odometer.
template<size_t N, size_t I>
struct odo_left_to_right {
  template<typename... Iters>
  static void apply(tuple<Iters...>& i,
                    tuple<Iters...> const& b,
                    tuple<Iters...> const& e)
  {
    // Only increment when you're non-empty.
    if(get<I>(i) == get<I>(e)) {
      // TODO: If the range in N (b, e] is guaranteed to be non-empty, then we
      // can omit this check.
      odo_left_to_right<N, I + 1>::apply(i, b, e);
    } else {
      // Incrementing the current element. If the increment pushes this past
      // the end, then increment the previous (next lower) iterator.
      ++get<I>(i);
      if(get<I>(i) == get<I>(e)) {
        get<I>(i) = get<I>(b);
        odo_left_to_right<N, I + 1>::apply(i, b, e);
      }
    }
  }
};

template<size_t N>
struct odo_left_to_right<N, N> {
  template<typename... Iters>
  static void apply(tuple<Iters...>& i,
                    tuple<Iters...> const& b,
                    tuple<Iters...> const& e)
  {
    if(get<N>(i) == get<N>(e)) {
      // Invalidate the entire counter.
      i = e;
    } else {
      ++get<N>(i);
      if(get<N>(i) == get<N>(e)) {
        get<N>(i) = get<N>(b);
        i = e;
      }
    }
  }
};

template<typename... Iters>
void incr_left_to_right(tuple<Iters...>& i,
                        tuple<Iters...> const& b,
                        tuple<Iters...> const& e) {
  odo_left_to_right<sizeof...(Iters) - 1, 0>::apply(i, b, e);
}

int main() {

  {
    Tuple i, b, e(2, 3, 4);
    int n = 0;
    for( ; i != e; incr_right_to_left(i, b, e)) {
      cout << n++ << " " << i << "\n";
    }
  }
  cout << "---------------\n";
  {
    Tuple i, b, e(2, 5, 3);
    int n = 0;
    for( ; i != e; incr_left_to_right(i, b, e)) {
      cout << n++ << " " << i << "\n";
    }
  }

  return 0;
}