////////////////////////////////////////////////////////////////////////////////////////////////
// lex_cast.hpp

// $Id: lex_cast.hpp,v 1.2 2005/06/20 13:20:04 my Exp $

//
// Copyright (C) 2005 mamba.ru
//

#ifndef LEX_CAST_HPP
#define LEX_CAST_HPP

#include <cstdlib>
#include <typeinfo>

#include "cpp-util/str_ref.hpp"

////////////////////////////////////////////////////////////////////////////////////////////////

namespace util {

////////////////////////////////////////////////////////////////////////////////////////////////

struct bad_lex_cast : std::bad_cast {};

////////////////////////////////////////////////////////////////////////////////////////////////

namespace detail {

template<class To, class From> 
struct lex_caster;

struct to_long
{
    static long cast(char const* f, char** p) { return ::strtol(f, p, 0); }
};

struct to_ulong
{
    static unsigned long cast(char const* f, char** p) { return ::strtoul(f, p, 0); }
};

template<class T, int signed = (T(-1) < 0)>
struct to_integral;

template<class T>
struct to_integral<T, 1> : to_long {};

template<class T>
struct to_integral<T, 0> : to_ulong {};

struct to_double
{
    static double cast(char const* f, char** p) { return ::strtod(f, p); }
};

template<class T> 
struct to_fundamental;

template<class T> 
struct to_fundamental : to_integral<T> {};

template<> 
struct to_fundamental<double> : to_double {};

template<class To>
struct fundamental_caster
{
    static To cast(str_ref src)
    {
        char const* const f = src.begin();
        char const* const e = f + src.size();
        char* p;
        To t = static_cast<To>(to_fundamental<To>::cast(f, &p));
        if(e != p)
            throw bad_lex_cast();
        return t;
    }
};

template<> struct lex_caster<bool,           str_ref> : fundamental_caster<bool> {};

template<> struct lex_caster<signed short,   str_ref> : fundamental_caster<signed short> {};
template<> struct lex_caster<signed int,     str_ref> : fundamental_caster<signed int> {};
template<> struct lex_caster<signed long,    str_ref> : fundamental_caster<signed long> {};

template<> struct lex_caster<unsigned short, str_ref> : fundamental_caster<unsigned short> {};
template<> struct lex_caster<unsigned int,   str_ref> : fundamental_caster<unsigned int> {};
template<> struct lex_caster<unsigned long,  str_ref> : fundamental_caster<unsigned long> {};

template<> struct lex_caster<double,         str_ref> : fundamental_caster<double> {};

}

////////////////////////////////////////////////////////////////////////////////////////////////

template<class To>
inline To lex_cast(str_ref str)
{
    return detail::lex_caster<To, str_ref>::cast(str);
}

template<class To>
inline To lex_cast(char const* f, char const* l)
{
    return lex_cast<To>(ref(f, l));
}

template<class To>
inline To lex_cast(char const* f)
{
    return lex_cast<To>(ref(f));
}

template<class To>
inline To lex_cast(std::string const& str)
{
    return lex_cast<To>(ref(str));
}

////////////////////////////////////////////////////////////////////////////////////////////////

} // namespace util {

////////////////////////////////////////////////////////////////////////////////////////////////

#endif // LEX_CAST_HPP