nullterminated.h

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

#ifndef LEAN_STRINGS_NULLTERMINATED
#define LEAN_STRINGS_NULLTERMINATED

#include "../lean.h"
#include "../meta/strip.h"
#include "../meta/type_traits.h"
#include "../meta/enable_if.h"
#include "char_traits.h"

namespace lean
{
namespace strings
{

struct nullterminated_incompatible { };

template <class Compatible, class Char, class Traits>
struct nullterminated_compatible : public nullterminated_incompatible
{
#ifdef DOXYGEN_READ_THIS


    static const Char* from(const Compatible &from);
    static const Char* from(const Compatible &from, const Char *begin);

    static Compatible to(const Char *begin);
    static Compatible to(const Char *begin, const Char *end);
#endif
};

template <class Compatible, class Char, class Traits>
struct is_nullterminated_compatible
{
    static const bool value = !is_derived<
        nullterminated_compatible<Compatible, Char, Traits>,
        nullterminated_incompatible>::value;
};

template <class Compatible, class Char, class Traits>
struct is_nullterminated_convertible
{
    static const bool value = is_equal<
                typename strip_modifiers<typename strip_pointer<typename strip_reference<Compatible>::type>::type>::type,
                typename strip_modifiers<Char>::type >::value
            || is_equal<
                typename strip_modifiers<typename strip_array<typename strip_reference<Compatible>::type>::type>::type,
                typename strip_modifiers<Char>::type >::value
            || is_nullterminated_compatible<Compatible, Char, Traits>::value;
};

template <class Compatible, class Char, class Traits>
struct assert_nullterminated_compatible
{
    static const bool is_compatible = is_nullterminated_compatible<Compatible, Char, Traits>::value;

    LEAN_STATIC_ASSERT_MSG_ALT(is_compatible,
        "Type incompatible with nullterminated character range class.",
        Type_incompatible_with_nullterminated_character_range_class);

    typedef void type;
};

template < class Char, class Traits = char_traits<typename strip_const<Char>::type> >
class nullterminated_implicit
{
public:
    typedef typename strip_const<Char>::type value_type;
    
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;

    typedef pointer iterator;
    typedef const_pointer const_iterator;

    typedef Traits traits_type;

protected:
    const_pointer m_begin;

    // /// Gets a pointer to this null-terminated range.
    // LEAN_INLINE operator Char*() const { return m_begin; }
    // DESIGN: Only permit implicit conversion to compatible container types, otherwise pointers might accidentally dangle.

public:
    LEAN_INLINE nullterminated_implicit(const_pointer begin)
        : m_begin(begin)
    {
        LEAN_ASSERT(m_begin);
    }
    template <class Compatible>
    LEAN_INLINE nullterminated_implicit(const Compatible &from,
            typename enable_if<is_nullterminated_compatible<Compatible, value_type, traits_type>::value, const void*>::type = nullptr)
        : m_begin(nullterminated_compatible<Compatible, value_type, traits_type>::from(from))
    {
        LEAN_ASSERT(m_begin);
    }

    LEAN_INLINE bool empty() const { return traits_type::empty(m_begin); }
    LEAN_INLINE size_type length() const { return traits_type::length(m_begin); }
    LEAN_INLINE size_type size() const { return length(); }
    LEAN_INLINE size_type count() const { return traits_type::count(m_begin); }
    
    LEAN_INLINE const_reference operator [](size_type pos) const { return m_begin[pos]; }
    
    LEAN_INLINE const_pointer c_str() const { return m_begin; }
    LEAN_INLINE const_pointer data() const { return c_str(); }

    LEAN_INLINE const_iterator begin() const { return m_begin; }
    LEAN_INLINE const_iterator end() const { return m_begin + length(); }

    LEAN_INLINE void swap(nullterminated_implicit& right)
    {
        const_pointer right_begin = right.m_begin;
        right.m_begin = m_begin;
        m_begin = right_begin;
    }

    template <class Compatible>
    Compatible to() const
    {
        typedef typename assert_nullterminated_compatible<
                Compatible,
                value_type, traits_type
            >::type assert_compatible;
        return nullterminated_compatible<Compatible, value_type, traits_type>::to(m_begin);
    }
};

template < class Char, class Traits = char_traits<typename strip_const<Char>::type> >
class nullterminated : public nullterminated_implicit<Char, Traits>
{
public:
    typedef nullterminated_implicit<Char, Traits> implicit_type;

    explicit LEAN_INLINE nullterminated(typename implicit_type::const_pointer begin)
        : implicit_type(begin)  { }
    template <class Compatible>
    explicit LEAN_INLINE nullterminated(const Compatible &from,
            typename enable_if<is_nullterminated_compatible<Compatible, value_type, traits_type>::value, const void*>::type = nullptr)
        : implicit_type(from) { }
    explicit LEAN_INLINE nullterminated(const implicit_type &right)
        : implicit_type(right)  { }
};

template <class Char, class Traits>
LEAN_INLINE nullterminated<Char, Traits> make_nt(const nullterminated_implicit<Char, Traits> &range)
{
    return nullterminated<Char, Traits>(range);
}
template <class Char>
LEAN_INLINE nullterminated<Char> make_nt(const Char *range)
{
    return nullterminated<Char>(range);
}
template <class Char, class Compatible>
LEAN_INLINE typename enable_if<
        is_nullterminated_compatible<Compatible, Char, typename nullterminated<Char>::traits_type>::value,
        nullterminated<Char>
    >::type make_nt(const Compatible &compatible)
{
    return nullterminated<Char>(compatible);
}

template <class Char, class Traits>
LEAN_INLINE bool operator ==(const nullterminated_implicit<Char, Traits>& left, const nullterminated_implicit<Char, Traits>& right)
{
    return nullterminated_implicit<Char, Traits>::traits_type::equal(left.c_str(), right.c_str());
}

template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator ==(const nullterminated_implicit<Char, Traits>& left, const Compatible& right) { return left == make_nt<Char, Traits>(right); }
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator ==(const Compatible& left, const nullterminated_implicit<Char, Traits>& right) { return make_nt<Char, Traits>(left) == right; }

template <class Char, class Traits>
LEAN_INLINE bool operator !=(const nullterminated_implicit<Char, Traits>& left, const nullterminated_implicit<Char, Traits>& right)
{
    return !(left == right);
}
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator !=(const nullterminated_implicit<Char, Traits>& left, const Compatible& right) { return left != make_nt<Char, Traits>(right); }
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator !=(const Compatible& left, const nullterminated_implicit<Char, Traits>& right) { return make_nt<Char, Traits>(left) != right; }

template <class Char, class Traits>
LEAN_INLINE bool operator <(const nullterminated_implicit<Char, Traits>& left, const nullterminated_implicit<Char, Traits>& right)
{
    return nullterminated_implicit<Char, Traits>::traits_type::less(left.c_str(), right.c_str());
}
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator <(const nullterminated_implicit<Char, Traits>& left, const Compatible& right) { return left < <make_nt<Char, Traits>(right); }
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator <(const Compatible& left, const nullterminated_implicit<Char, Traits>& right) { return make_nt<Char, Traits>(left) < right; }

template <class Char, class Traits>
LEAN_INLINE bool operator >(const nullterminated_implicit<Char, Traits>& left, const nullterminated_implicit<Char, Traits>& right)
{
    return (right < left);
}
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator >(const nullterminated_implicit<Char, Traits>& left, const Compatible& right) { return left > <make_nt<Char, Traits>(right); }
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator >(const Compatible& left, const nullterminated_implicit<Char, Traits>& right) { return make_nt<Char, Traits>(left) > right; }

template <class Char, class Traits>
LEAN_INLINE bool operator <=(const nullterminated_implicit<Char, Traits>& left, const nullterminated_implicit<Char, Traits>& right)
{
    return !(right < left);
}
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator <=(const nullterminated_implicit<Char, Traits>& left, const Compatible& right) { return left <= <make_nt<Char, Traits>(right); }
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator <=(const Compatible& left, const nullterminated_implicit<Char, Traits>& right) { return make_nt<Char, Traits>(left) <= right; }

template <class Char, class Traits>
LEAN_INLINE bool operator >=(const nullterminated_implicit<Char, Traits>& left, const nullterminated_implicit<Char, Traits>& right)
{
    return !(left < right);
}
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator >=(const nullterminated_implicit<Char, Traits>& left, const Compatible& right) { return left >= <make_nt<Char, Traits>(right); }
template <class Char, class Traits, class Compatible>
LEAN_INLINE typename enable_if<is_nullterminated_convertible<Compatible, Char, Traits>::value, bool>::type
    operator >=(const Compatible& left, const nullterminated_implicit<Char, Traits>& right) { return make_nt<Char, Traits>(left) >= right; }

template <class Char, class Traits>
LEAN_INLINE void swap(nullterminated_implicit<Char, Traits>& left, nullterminated_implicit<Char, Traits>& right)
{
    left.swap(right);
}

} // namespace

using strings::nullterminated_implicit;
using strings::nullterminated;

using strings::make_nt;

} // namespace

#endif