char_traits.h

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

#ifndef LEAN_STRINGS_CHAR_TRAITS
#define LEAN_STRINGS_CHAR_TRAITS

#include "../lean.h"
#include <cstring>
#include <cwchar>

namespace lean
{
namespace strings
{

template <class Char>
struct char_traits
{
    typedef Char char_type;
    typedef typename int_type<sign_class::no_sign, sizeof(char_type)>::type int_type;
    typedef size_t size_type;
    
    static LEAN_INLINE bool null(const char_type &src)
    {
        return (src == static_cast<char_type>(0));
    }

    static LEAN_INLINE bool empty(const char_type *begin)
    {
        return null(*begin);
    }
    static size_type length(const char_type *begin)
    {
        size_t length = 0;

        while (!null(*begin++))
            ++length;

        return length;
    }
    static LEAN_INLINE size_type count(const char_type *begin)
    {
        return length(begin);
    }
    static LEAN_INLINE size_type count(const char_type *begin, const char_type *end)
    {
        return end - begin;
    }

    static bool equal(const char_type *begin1, const char_type *begin2)
    {
        while (*begin1 == *begin2)
        {
            if (null(*begin1))
                return true;

            ++begin1;
            ++begin2;
        }

        return false;
    }
    static bool less(const char_type *begin1, const char_type *begin2)
    {
        while (*begin1 == *begin2)
        {
            if (null(*begin1))
                return false;

            ++begin1;
            ++begin2;
        }

        // Compare unsigned, correctly handles null (end of string) as smallest number
        return static_cast<int_type>(*begin1) < static_cast<int_type>(*begin2);
    }
};

template <>
struct char_traits<char>
{
    typedef char char_type;
    typedef int_type<sign_class::no_sign, sizeof(char_type)>::type int_type;
    typedef size_t size_type;
    
    static LEAN_INLINE bool null(const char_type &src)
    {
        return (src == static_cast<char_type>(0));
    }
    
    static LEAN_INLINE bool empty(const char_type *begin)
    {
        return null(*begin);
    }
    static LEAN_INLINE size_type length(const char_type *begin)
    {
        using std::strlen;
        return strlen(begin);
    }
    static LEAN_INLINE size_type count(const char_type *begin)
    {
        return length(begin);
    }
    static LEAN_INLINE size_type count(const char_type *begin, const char_type *end)
    {
        return end - begin;
    }

    static bool equal(const char_type *begin1, const char_type *begin2)
    {
        using std::strcmp;
        return (strcmp(begin1, begin2) == 0);
    }
    static bool less(const char_type *begin1, const char_type *begin2)
    {
        using std::strcmp;
        return (strcmp(begin1, begin2) < 0);
    }
};

template <>
struct char_traits<wchar_t>
{
    typedef wchar_t char_type;
    typedef int_type<sign_class::no_sign, sizeof(char_type)>::type int_type;
    typedef size_t size_type;
    
    static LEAN_INLINE bool null(const char_type &src)
    {
        return (src == static_cast<char_type>(0));
    }
    
    static LEAN_INLINE bool empty(const char_type *begin)
    {
        return null(*begin);
    }
    static LEAN_INLINE size_type length(const char_type *begin)
    {
        using std::wcslen;
        return wcslen(begin);
    }
    static LEAN_INLINE size_type count(const char_type *begin)
    {
        return length(begin);
    }
    static LEAN_INLINE size_type count(const char_type *begin, const char_type *end)
    {
        return end - begin;
    }

    static bool equal(const char_type *begin1, const char_type *begin2)
    {
        using std::wcscmp;
        return (wcscmp(begin1, begin2) == 0);
    }
    static bool less(const char_type *begin1, const char_type *begin2)
    {
        using std::wcscmp;
        return (wcscmp(begin1, begin2) < 0);
    }
};

} // namespace

using strings::char_traits;

} // namespace

#endif