//@doc/////////////////////////////////////////////////////////////////////////////////////////
//
//             SIERRA S.R.L. - Tecnología y Servicio - Departamento de Software.
//
//=============================================================================================
// Generic Numeric Conversion. Fernando Cacciola.
//
// 23/06/2000 FLC Initial build.
// 28/06/2000 FLC range code move to numeric_bounds.h
//
#ifndef  __RTL_CVT_N_H_
#define  __RTL_CVT_N_H_

#include "numeric_bounds.h"

#define NO_STATIC_COVARIANT

// cvt_traits is used for the 'return type optimization'.
// When the conversion is performed between equal types, the return type is
// just a reference to the parameter, allowing the compiler to completely
// bypass the conversion.
template<typename T,typename S> struct cvt_traits      { typedef T        ret_type ; } ;
template<typename S>            struct cvt_traits<S,S> { typedef S const& ret_type ; } ;


namespace gmath {

//----------------------------------------------------------------------------------------
// This auxiliary function throws an exception in the case of an out of range.
// It recieves the original value 's' and returns a value of type T.
// For a given pair T,S, this can be specialized so that some value of type T is
// returned, perhaps a closer match.
// By default, a cvt_range_error() exception is thrown (see below).
//

//----------------------------------------------------------------------------------------
// cvt_range_error
// This exception class contains all the information about the types and values
// being converted.
// It has a record of the typenames of T and S and of their actual values.
//
  struct cvt_range_error : std::range_error
  {
    struct values_base
    {
      values_base ( std::string const& t_typename_ ,
                    std::string const& s_typename_
                  )
        :
        t_typename(t_typename_),
        s_typename(s_typename_),
        refs      (0)
      {}
      virtual ~ values_base(){}
      std::string t_typename ;
      std::string s_typename ;
      int refs ;
    } ;
    template<typename T,typename S>
    struct values_impl : values_base
    {
      values_impl ( T const& _t , S const& _s )
        :
        values_base ( typeid(_t).name() , typeid(_s).name() ) ,
        t ( _t ) , s ( _s )
        {}
      T t ;
      S s ;
    } ;
    template<typename T,typename S>
    cvt_range_error ( std::string const& msg ,
                      S const& s ,
                      T const& t
                     )
      : std::range_error(msg) ,
        values ( new values_impl<T,S> ( t , s ) )
    {
      values->refs ++ ;
    }
    cvt_range_error ( cvt_range_error const& rhs )
      :
      std::range_error ( rhs ) ,
      values ( rhs.values)
    {
      values->refs ++ ;
    }
    ~ cvt_range_error()
    {
      if ( -- values->refs == 0 )
        delete values ;
    }
    values_base* values;
  } ;
//----------------------------------------------------------------------------------------


template<typename T,typename S>
T cvt_out_of_range_error( S const& s , int sign )
{
  T t = sign == -1 ? numeric_bounds<T>::lowest() : numeric_bounds<T>::highest() ;

  throw cvt_range_error( "out-of-range conversion" , s , t ) ;
}
//----------------------------------------------------------------------------------------


// The following identifiers are implementation specific, thus they are hidden in
// a private namespace.
namespace cvt_n_aux {

// IMPLEMENTATION NOTE:
// The explicit casts throughout this code are needed to tell the compiler
// that a lose of precision is ok. Without them, most compilers will yield the
// warning: 'convertion might lose significant digits'

// ret_traits is used for the 'return type optimization'.
// When the conversion is performed between equal types, the return type is
// just a reference to the parameter, allowing the compiler to completely
// bypass the conversion.
template<typename T,typename S> struct ret_traits      { typedef T        type ; } ;
template<typename S>            struct ret_traits<S,S> { typedef S const& type ; } ;

// Inner conversion procedure.
template<typename T,typename S>
struct convert
{
  // By default(check_range=false) just call Round() and cast the result.
  template<typename rounder>
  static ret_traits<T,S>::type cvt ( S const& s , rounder Round )
  {
    int sg = numeric_bounds_comparison<T,S>::test(s) ;
    if ( sg != 0 )
         return (ret_traits<T,S>::type)cvt_out_of_range_error<T,S>(s,sg);
    else return (ret_traits<T,S>::type)Round(s) ;
  }
} ;

// rounding_dispatch
template<typename T,typename S,bool round_it> struct rounding_dispatch {} ;

// rounding_dispatch specialization for rounding conversions.
template<typename T,typename S>
struct rounding_dispatch<T,S,true>
{
  // round is a free template function declared above.
  static S round_it ( S const& s ) { return round(s) ; }

  static ret_traits<T,S>::type cvt ( S const& s )
  { return convert<T,S>::cvt(s,round_it) ; }
} ;

// rounding_dispatch specialization for non-rounding conversions.
template<typename T,typename S>
struct rounding_dispatch<T,S,false>
{
  // round is a free template function declared above.
  static S const& not_round_it ( S const& s ) { return s ; }

  static ret_traits<T,S>::type cvt ( S const& s )
  { return convert<T,S>::cvt(s,not_round_it) ; }
} ;

// main_dispatch.
// cvt implementation for T!=S
template<typename T,typename S> struct main_dispatch
{
  static ret_traits<T,S>::type cvt ( S const& s )
  {
    return rounding_dispatch<T,
                             S,
                                 std::numeric_limits<T>::is_integer
                             && !std::numeric_limits<S>::is_integer
                            >::cvt(s);
  }
} ;

// main_dispatch.
// cvt implementation for T==S.
template<typename S> struct main_dispatch<S,S>
{
  // ret_traits<S,S>::type is expanded to S const& so this is effectively
  // bypassed.
  static ret_traits<S,S>::type cvt ( S const& s ) { return s ; }
} ;

} // namespace cvt_n_aux


//////////////////////////////////////////////////////////////////////////////////////////
//
// T t = cvt_n<T>(s)
//
// Converts from numeric S to numeric T.
// The following optimizations are performed:
//
//  1) Conversion between equal types are effectively bypassed.
//     S v ; S u = cvt_n<S>(v) ; // Expands to: S u = v ;
//
//  2) Range checking is applied, but is controlled by a traits.
//     For built-in types, range checking is bypassed if convertion goes to
//     a bigger range type:
//       int u = cvt_n<int>( (short) 1 ) ; // No range checking.
//
//     Mixing signed/unsigned types forces range checking:
//
//       int u = cvt_n<int> ( (unsigned int) 1) ; // range checking.
//
//  3) Rounding is applied when converting from a non-integer type to an
//     integer type (in other cases rounding is not applied).
//     The rounding is performed by a free template function round() which can
//     be specialized.
//     Range checking is combined to ensure proper conversion after rounding.
//
//       int   u = cvt_n<int>(2.5) ; // rounding and range checking.
//       float v = cvt_n<float)(2.5) ; // no explicit rounding.
//
//  4) Supports user defined types if they specialize numeric_limits<> and
//     provides applicable constructors and conversion operators.
//
template<typename T,typename S> inline
cvt_n_aux::ret_traits<T,S>::type cvt_n ( S const& s )
{
  // A template dispatch engine selects the apropriate implementations according
  // to the properties of S and T.
  return cvt_n_aux::main_dispatch<T,S>::cvt(s);
}


} //namespace gmath.

using gmath::cvt_n ;

#endif
//
///////////////////////////////////////////////////////////////////////////////////////////////