// Copyright {Jagger Software Limited} 2003

#if !defined CONTAINER_LINE_VIEW_INCLUDED || \
     defined CONTAINER_LINE_VIEW_TEMPLATE_INCLUDED
#error      "container/line_view-template.hpp" #included directly
#endif

#define      CONTAINER_LINE_VIEW_TEMPLATE_INCLUDED
     
#include "array/end_of.hpp"
#include <algorithm>
#include <stdexcept>

namespace container // line_view - 'tor
{
    template<typename iterator>
    line_view<iterator>::line_view(iterator begin, iterator end)
        : source(begin, end)
    {
        line_starts.push_back(0);

        while (begin != end)
        {
            static const char eol[] = "\r\n";

            begin = std::find_first_of(begin, end, eol, array::end_of(eol));

            if (begin != end && *begin++ == '\r' && 
                begin != end && *begin == '\n')
            {
                ++begin;
            }
 
            line_starts.push_back(distance_to(begin));
        }
    }
}

namespace container // limits
{
    template<typename iterator>
    iterator
    line_view<iterator>::begin() const
    {
        return source.begin;
    }

    template<typename iterator>
    iterator
    line_view<iterator>::end() const
    {
        return source.end;
    }
}

namespace container // iterator --> line/row/col
{
    template<typename iterator>
    range_view<iterator> 
    line_view<iterator>::to_line(iterator at) const
    {
        return (*this)[line_number(at)];
    }

    template<typename iterator>
    size_t
    line_view<iterator>::line_number(iterator at) const
    {
        return iterator_to_line_number(at);
    }

    template<typename iterator>
    size_t
    line_view<iterator>::column_number(iterator at) const
    {
        const iterator line_start = 
            line_number_to_line_start(line_number(at) - 1);

        return ::std::distance(line_start, at) + 1; 
    }
}

namespace container // line# -> line
{
    template<typename iterator>
    size_t
    line_view<iterator>::last_line_number() const
    {
        return line_starts.size() - 1;
    }

    template<typename iterator>
    range_view<iterator> 
    line_view<iterator>::operator[](size_t at) const
    {
        range_check(at);
         
        return make_range_view(line_number_to_line_start(at - 1), 
                               line_number_to_line_start(at));
    }
}

namespace container // implementation
{
    template<typename iterator>
    size_t
    line_view<iterator>::distance_to(iterator at) const
    {
        return ::std::distance(source.begin, at);
    }

    template<typename iterator>
    size_t
    line_view<iterator>::iterator_to_line_number(iterator position) const
    {
        const size_t offset = distance_to(position); 

        for (size_t at = 1; at != line_starts.size(); ++at)
        {
            if (offset < line_starts[at])
            {
                return at;
            }
        }

        throw ::std::out_of_range("container::line_view<>::iterator"); 
    }

    template<typename iterator>
    iterator 
    line_view<iterator>::line_number_to_line_start(size_t at) const
    {
        return begin() + line_starts[at];       
    }
}

namespace container // validation
{
    template<typename iterator>
    void
    line_view<iterator>::range_check(size_t at) const
    {
        if (at < 1 || at > last_line_number()) // [1, last_line_number()]
        {
            throw ::std::out_of_range("container::line_view<>::line#");
        }
    }
}

namespace container // convenience
{
    template<typename iterator>
    line_view<iterator> make_line_view(iterator begin, iterator end)
    {
        return line_view<iterator>(begin, end);
    }
}