range.h

/*****************************************************/
/* lean Strings                 (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_STRINGS_RANGE
#define LEAN_STRINGS_RANGE

#include "../lean.h"
#include "../meta/strip.h"
#include "../meta/type_traits.h"
#include "../meta/enable_if.h"
#include <iterator>

namespace lean
{
namespace strings
{

template <class Iterator>
class range
{
private:
    Iterator m_begin;
    Iterator m_end;

public:
    typedef Iterator iterator;
    typedef Iterator const_iterator;

    LEAN_INLINE range()
        : m_begin(), m_end() { }
    LEAN_INLINE range(iterator begin, iterator end)
        : m_begin(begin), m_end(end) { }

    LEAN_INLINE void assign(iterator begin, iterator end)
    {
        m_begin = begin;
        m_end = end;
    }

    LEAN_INLINE bool empty() const { return (m_begin == m_end); }
    LEAN_INLINE size_t size() const { return m_end - m_begin; }

    LEAN_INLINE iterator& begin() { return m_begin; }
    LEAN_INLINE iterator begin() const { return m_begin; }
    LEAN_INLINE iterator& end() { return m_end; }
    LEAN_INLINE iterator end() const { return m_end; }

    LEAN_INLINE typename std::iterator_traits<iterator>::reference operator [](size_t n) const { return *(begin() + n); }
};


template <class Iterator>
LEAN_INLINE range<Iterator> make_range(Iterator begin, Iterator end)
{
    return range<Iterator>(begin, end);
}

template <class Char>
LEAN_INLINE range<Char*> make_char_range(Char *nts)
{
    return range<Char*>(
        nts,
        nts + std::char_traits<typename strip_modifiers<Char>::type>::length(nts) );
}
template <class Range>
LEAN_INLINE Range& make_char_range(Range &range) { return range; }


template <class Class, class Range>
LEAN_INLINE Class from_range(const Range &range)
{
    return Class(range.begin(), range.end());
}

template <class String>
struct string_traits;

template <class String, class Range>
LEAN_INLINE String string_from_range(const Range &range)
{
    return string_traits<String>::construct(range.begin(), range.end());
}

namespace impl
{
    LEAN_DEFINE_HAS_TYPE(iterator);
}

template <class Type>
struct is_range
{
    static const bool value = impl::has_type_iterator<Type>::value;
};

template <class Range, class Type>
struct enable_if_range : public enable_if<is_range<Range>::value, Type> { };
template <class Range, class Type>
struct enable_if_not_range : public enable_if<!is_range<Range>::value, Type> { };
template <class Range1, class Range2, class Type>
struct enable_if_range2 : public enable_if<is_range<Range1>::value && is_range<Range2>::value, Type> { };
template <class Range1, class Range2, class Type>
struct enable_if_not_range2 : public enable_if<!is_range<Range1>::value || !is_range<Range2>::value, Type> { };

template <class Chars1>
struct range_char_type;
template <class Char>
struct range_char_type<Char*> { typedef typename strip_modifiers<Char>::type type; };

template <class Chars1, class Chars2>
struct range_char_type2;
template <class Char, class Chars2>
struct range_char_type2<Char*, Chars2> { typedef typename strip_modifiers<Char>::type type; };
template <class Chars1, class Char>
struct range_char_type2<Chars1, Char*> { typedef typename strip_modifiers<Char>::type type; };
template <class Char1, class Char2>
struct range_char_type2<Char1*, Char2*> { typedef typename strip_modifiers<Char1>::type type; };

} // namespace

using strings::range;
using strings::make_range;
using strings::make_char_range;
using strings::from_range;
using strings::string_from_range;
using strings::is_range;
using strings::enable_if_range;
using strings::enable_if_not_range;
using strings::enable_if_range2;
using strings::enable_if_not_range2;
using strings::range_char_type;
using strings::range_char_type2;

} // namespace

#endif