#ifndef INCLUDE_GUARD_TAIL_HH
#define INCLUDE_GUARD_TAIL_HH

#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/range_ex/transform.hpp>
#include <boost/static_assert.hpp>
#include <boost/tuple/tuple.hpp>


enum EmptyRange { };

template <typename SinglePassRange>
struct tail_range :
    boost::iterator_range<typename boost::range_result_iterator<SinglePassRange>::type>
{

public:

    typedef typename boost::range_result_iterator<SinglePassRange>::type iterator;
    typedef boost::iterator_range<iterator> base_range;

    BOOST_CLASS_REQUIRE(iterator, boost_concepts, SinglePassIteratorConcept);

    explicit tail_range(SinglePassRange &range) :
        base_range(skip_front(range), boost::end(range))
    {
    }

private:

    static iterator skip_front(SinglePassRange &range)
    {
        if (boost::empty(range))
            throw EmptyRange();
        return ++boost::begin(range);
    }

};

template <typename SinglePassRange>
tail_range<SinglePassRange> make_tail_range(SinglePassRange &range)
{
    return tail_range<SinglePassRange>(range);
}
template <typename SinglePassRange>
tail_range<SinglePassRange const> make_tail_range(SinglePassRange const &range)
{
    return tail_range<SinglePassRange const>(range);
}


namespace detail
{

struct tail_range_adaptor
{
    template <typename SinglePassRange, typename Args>
    struct apply
    {
        BOOST_STATIC_ASSERT((boost::tuples::length<Args>::value == 0));
        typedef tail_range<SinglePassRange> type;
    };
    template <typename SinglePassRange, typename Args>
    static typename apply<SinglePassRange, Args>::type
    make_range(SinglePassRange &range, Args)
    {
        return make_tail_range(range);
    }
};

}   // namespace detail


boost::range_adaptor<tail_range_adaptor> const tail;


#endif  // !INCLUDE_GUARD_TAIL_HH