// Copyright {Jagger Software Limited} 2003

#if !defined CONTAINER_STRAND_VIEW_INCLUDED || \
     defined CONTAINER_STRAND_VIEW_TEMPLATE_INCLUDED
#error      "container/strand_view_view-template.hpp" #included directly
#endif
#define      CONTAINER_STRAND_VIEW_TEMPLATE_INCLUDED

#include "container/range_view.hpp"
#include "contract/pre_condition.hpp"
#include <cstring>
#include <algorithm>
#include <iostream>
#include <stdexcept>

namespace container // strand_view - 'tors
{
    template<typename iterator>
    strand_view<iterator>::strand_view(const range_view<iterator> & source)
        : from(source.begin)
        , until(source.end)
    {
    }
    
    template<typename iterator>
    strand_view<iterator>::strand_view(iterator start, iterator finish)
        : from(start)
        , until(finish)
    {
    }
}

namespace container // strand_view - capacity
{
    template<typename iterator>
    bool strand_view<iterator>::empty() const
    {
        return size() == 0;
    }

    template<typename iterator>
    size_t strand_view<iterator>::size() const
    {
        return std::distance(begin(), end());
    }
}

namespace container // strand_view - conversion
{
    using std::string;

    template<typename iterator>
    string strand_view<iterator>::as_string() const
    {
        return string(begin(), end());
    }
}

namespace container // strand_view - iteration
{
    template<typename iterator>
    iterator strand_view<iterator>::begin() const
    {
        return from;
    }

    template<typename iterator>
    iterator strand_view<iterator>::end() const
    {
        return until;
    }
}

namespace container // strand_view - end element access
{
    template<typename iterator>
    char strand_view<iterator>::front() const
    {
        PRE_CONDITION(!empty());
        return begin()[0];
    }
    
    template<typename iterator>
    char strand_view<iterator>::back() const
    {
        PRE_CONDITION(!empty());
        return (*this)[size() - 1];
    }
}

namespace container // strand_view - subscripting
{ 
    template<typename iterator>
    char strand_view<iterator>::operator[](size_t at) const
    {
        range_check(at);
        return begin()[at];
    }

}

namespace container // strand_view - validation
{
    template<typename iterator>
    void strand_view<iterator>::range_check(size_t at) const
    {
        if (at >= size())
        {
            throw ::std::out_of_range("container::strand_view<>::operator[at]");
        }
    }
}

namespace container // strand_view - convenience
{
    template<typename iterator>
    strand_view<iterator> make_strand_view(iterator lhs, iterator rhs)
    {
        return strand_view<iterator>(lhs, rhs);
    }

    template<typename iterator>
    strand_view<iterator> make_strand_view(const range_view<iterator> & source)
    {
        return strand_view<iterator>(source.begin, source.end);
    }
}

namespace container // strand_view - streaming
{
    template<typename iterator>
    ::std::ostream & 
    operator<<(::std::ostream & out, const strand_view<iterator> & written)
    {
        for (size_t at = 0; at != written.size(); ++at)
        {
            out << written[at];
        }
    
        return out;
    }
}
    
namespace // implementation
{
    template<typename lhs_iterator, typename rhs_iterator>
    bool equal(const ::container::strand_view<lhs_iterator> & lhs,
               const ::container::strand_view<rhs_iterator> & rhs)
    {
        return lhs.size() == rhs.size() &&
               ::std::equal(lhs.begin(), lhs.end(), rhs.begin());
    }

    template<typename iterator>
    bool equal(const ::container::strand_view<iterator> & lhs,
               const ::std::string & rhs)
    {
        return lhs.size() == rhs.size() &&
               ::std::equal(lhs.begin(), lhs.end(), rhs.begin());
    }

    template<typename iterator>
    bool equal(const ::container::strand_view<iterator> & lhs,
               const char * rhs)
    {
        PRE_CONDITION(rhs != 0);

        return lhs.size() == std::strlen(rhs) &&
               ::std::equal(lhs.begin(), lhs.end(), rhs);
    }
}

namespace container // strand_view - in/equality
{
    template<typename lhs_iterator, typename rhs_iterator>
    bool operator==(const strand_view<lhs_iterator> & lhs, 
                    const strand_view<rhs_iterator> & rhs)
    {
        return ::equal(lhs, rhs);
    }
    
    template<typename lhs_iterator, typename rhs_iterator>
    bool operator!=(const strand_view<lhs_iterator> & lhs, 
                    const strand_view<rhs_iterator> & rhs)
    {
        return !::equal(lhs, rhs);
    }
    
    template<typename iterator>
    bool operator==(const strand_view<iterator> & lhs, 
                    const ::std::string & rhs)
    {
        return ::equal(lhs, rhs);
    }
    
    template<typename iterator>
    bool operator!=(const strand_view<iterator> & lhs, 
                    const ::std::string & rhs)
    {
        return !::equal(lhs, rhs);
    }
    
    template<typename iterator>
    bool operator==(const ::std::string & lhs, 
                    const strand_view<iterator> & rhs)
    {
        return ::equal(rhs, lhs);
    }
    
    template<typename iterator>
    bool operator!=(const ::std::string & lhs, 
                    const strand_view<iterator> & rhs)
    {
        return !::equal(rhs, lhs);
    }
    
    template<typename iterator>
    bool operator==(const strand_view<iterator> & lhs, 
                    const char * rhs)
    {
        return ::equal(lhs, rhs);
    }
    
    template<typename iterator>
    bool operator!=(const strand_view<iterator> & lhs, 
                    const char * rhs)
    {
        return !::equal(lhs, rhs);
    }
    
    template<typename iterator>
    bool operator==(const char * lhs, 
                    const strand_view<iterator> & rhs)
    {
        return ::equal(rhs, lhs);
    }
    
    template<typename iterator>
    bool operator!=(const char * lhs, 
                    const strand_view<iterator> & rhs)
    {
        return !::equal(rhs, lhs);
    }
}