// Boost.Range library
//
//  Copyright Thorsten Ottosen 2003-2004. 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)
//
// For more information, see http://www.boost.org/libs/range/
//

#ifndef BOOST_RANGE_SUB_RANGE_HPP
#define BOOST_RANGE_SUB_RANGE_HPP

#include <boost/range/config.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/range/size_type.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/assert.hpp>

namespace boost
{
    
    template< class ForwardRange > 
    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type > 
    {
        typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type iterator_t;
        typedef iterator_range< iterator_t  > base;
        
    public:
        typedef BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type            value_type;
        typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type  iterator;
        typedef BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type   const_iterator;
        typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type       difference_type;
        typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type             size_type;

    public:
        sub_range() : base() 
        { }
            
        template< class ForwardRange2 >
        sub_range( ForwardRange2& r ) : 
            
#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
            base( boost::begin( r ), boost::end( r ) )
#else
            base( r )
#endif        
        { }
        
        template< class ForwardRange2 >
        sub_range( const ForwardRange2& r ) : 

#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
            base( boost::begin( r ), boost::end( r ) )
#else
            base( r )
#endif                
        { }

        template< class Iter >
        sub_range( Iter first, Iter last ) :
            base( first, last )
        { }
        
        template< class ForwardRange2 >
        sub_range& operator=( ForwardRange2& r )
        {
            base::operator=( r );
            return *this;
        }

        template< class ForwardRange2 >
        sub_range& operator=( const ForwardRange2& r )
        {
            base::operator=( r );
            return *this;
        }
        
    public:
        
        iterator        begin()          { return base::begin(); }
        const_iterator  begin() const    { return base::begin(); }
        iterator        end()            { return base::end();   }
        const_iterator  end() const      { return base::end();   }
        size_type       size() const     { return base::size();  }   

        
    public: // convenience
        value_type& front()
        {
            BOOST_ASSERT( !empty() );
            return *m_Begin;
        }

        const value_type& front() const
        {
            BOOST_ASSERT( !empty() );
            return *m_Begin;
        }

        value_type& back()
        {
            BOOST_ASSERT( !empty() );
            return *--m_End;
        }

        const value_type& back() const
        {
            BOOST_ASSERT( !empty() );
            return *--m_End;
        }

        value_type& operator[]( size_type sz )
        {
            //BOOST_STATIC_ASSERT( is_random_access );
            BOOST_ASSERT( sz < size() );
            return m_Begin[sz];
        }

        const value_type& operator[]( size_type sz ) const
        {
            //BOOST_STATIC_ASSERT( is_random_access );
            BOOST_ASSERT( sz < size() );
            return m_Begin[sz];
        }

        value_type& at( size_type sz )
        {
            //BOOST_STATIC_ASSERT( is_random_access );
            if( sz < size() )
                   throw "foo";
            return m_Begin[sz];
        }

        const value_type& at( size_type sz ) const
        {
            //BOOST_STATIC_ASSERT( is_random_access );
            if( sz < size() )
                   throw "foo";
            return m_Begin[sz];
        }

    public: // iterable
        value_type& operator*()
        {
            BOOST_ASSERT( !empty() );
            return front();
        }

        const value_type& operator*() const
        {
            BOOST_ASSERT( !empty() );
            return front();
        }
    };

    template< class ForwardRange, class ForwardRange2 >
    inline bool operator==( const sub_range<ForwardRange>& l,
                            const sub_range<ForwardRange2>& r )
    {
        return range_detail::equal( l, r );
    }

    template< class ForwardRange, class ForwardRange2 >
    inline bool operator!=( const sub_range<ForwardRange>& l,
                            const sub_range<ForwardRange2>& r )
    {
        return !range_detail::equal( l, r );
    }

    template< class ForwardRange, class ForwardRange2 >
    inline bool operator<( const sub_range<ForwardRange>& l,
                           const sub_range<ForwardRange2>& r )
    {
        return range_detail::less_than( l, r );
    }


} // namespace 'boost'

#endif