scalt4.cpp

Go to the documentation of this file.

#include "scalt0.hpp"

#include <iostream>

#include <ql/utilities/tracing.hpp>
#include <boost/date_time/gregorian/formatters.hpp>

#include "scal0.hpp"

namespace eepgwde { namespace detail { namespace i0 {

  template <typename U>
  typename enable_if<boost::is_arithmetic<U>, U>::type 
  null1(dummy<0> = 0) { return std::numeric_limits<U>::min(); }

  template <typename U>
  typename enable_if<boost::is_base_of<std::string, U>, U>::type 
  null1(dummy<0> = 1) { return std::string(""); }

  template <typename U>
  typename enable_if<boost::is_base_of<boost::gregorian::date, U>, U>::type 
  null1(dummy<0> = 2) {
    return boost::gregorian::date(1901,1,1);
  }

  template <typename U>
  typename enable_if_c<boost::is_arithmetic<typename U::value_type>::value && !boost::is_base_of<std::string, U>::value, U>::type 
  null1(dummy<0> = 3) {
    return null1<typename U::value_type>();
  }

  template <typename U>
  typename enable_if<boost::is_base_of<boost::any, U>, U>::type 
  null1(dummy<0> = 4) {
    return boost::any();
  }

  template <typename U>
  typename disable_if_c<boost::is_base_of<boost::any, U>::value ||
  boost::is_arithmetic<U>::value ||
  boost::is_arithmetic<typename U::value_type>::value ||
  boost::is_base_of<std::string, U>::value ||
  !(boost::has_trivial_default_constructor<U>::value)
    , U>::type 
  null1(dummy<1> = 1) {
    return U();
  }

  template <typename U>
  std::string
  ys(typename enable_if<boost::is_arithmetic<U>, U>::type,
     const boost::any &o, dummy<1> = 1)
    throw (std::domain_error &) {
    U r(boost::any_cast<U>(o));
    return boost::lexical_cast<std::string>(r);
  }

  template <typename U>
  std::string
  ys(typename enable_if<boost::is_same<boost::gregorian::date, U>, U>::type,
     const boost::any &o, dummy<1> = 1)
    throw (std::domain_error &) {
    U r(boost::any_cast<U>(o));
    return boost::gregorian::to_simple_string(r);
  }

  template <typename U>
  U xs(typename disable_if_c<
       boost::is_base_of<boost::gregorian::date, U>::value ||
       boost::is_base_of<boost::any, U>::value
       , U>::type,
       const std::string & s, dummy<1> = 2)
    throw (std::domain_error &) {
    return boost::lexical_cast<U>(s);
  }

  template <typename U>
  U xs(typename enable_if<boost::is_same<boost::gregorian::date, U>, U>::type,
       const std::string & s, dummy<1> = 2)
    throw (std::domain_error &) {
    boost::gregorian::date dt = boost::gregorian::from_simple_string(s);
    return dt;
  }

  template <typename U>
  U xs(typename enable_if<boost::is_same<usdate, U>, U>::type,
       const std::string & s, dummy<1> = 2)
    throw (std::domain_error &) {
    U dt = boost::gregorian::from_us_string(s);
    return dt;
  }

  template <typename U>
  U xs(typename enable_if<boost::is_same<eudate, U>, U>::type,
       const std::string & s, dummy<1> = 2)
    throw (std::domain_error &) {
    U dt = boost::gregorian::from_uk_string(s);
    return dt;
  }

  template <typename U>
  U xs(typename enable_if<boost::is_base_of<boost::any, U>, U>::type,
       const std::string & s, dummy<1> = 2)
    throw (std::domain_error &) {
    return boost::any();
  }

}}}

#include "eleve/src/typing1.hpp"

BOOST_AUTO_TEST_SUITE (typing4)

  using namespace eepgwde::detail;
using namespace boost;

BOOST_AUTO_TEST_CASE(tas0)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as0");

  using namespace eepgwde::detail;

  {
    Rate0 d(2);
    boost::any o(d);
    std::string s1;
    try {
      s1 = any_cast<std::string>(o);
    } catch (...) {
      s1="failed";
    }

    BOOST_TEST_MESSAGE( d << " " << s1 );
  }

  {
    std::string s("1");
    boost::any o(s);

    std::string s1 = any_cast<std::string>(o);

    unsigned long d1 = lexical_cast<unsigned long>(s1);
    Rate0::value_type d2 = lexical_cast<Rate0::value_type>(s1);
    Rate0 d3 = lexical_cast<Rate0>(s1);

    BOOST_TEST_MESSAGE( d1 << " " << d2 << " " << d3 );
  }

}

BOOST_AUTO_TEST_CASE(tas2)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as2");

  using namespace eepgwde::detail;

  {
    int s(1);
    boost::any o(s);

    std::string si0 = i0::ys<int>((null0<int>())(), o, i0::dummy<1>(1) );

    BOOST_TEST_MESSAGE( si0 );
  }
}

BOOST_AUTO_TEST_CASE(tas21)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as21");

  using namespace eepgwde::detail;

  {
    string s("1");
    boost::any o(s);

    int i0 = i0::xs<int>((null0<int>())(), s, i0::dummy<1>(2) );

    BOOST_TEST_MESSAGE( s << " " << i0 );
  }

  {
    string s("2009-11-12");
    boost::any o(s);

    boost::gregorian::date
      i0 = i0::xs<boost::gregorian::date>((null0<boost::gregorian::date>())(), s, i0::dummy<1>(2) );

    BOOST_TEST_MESSAGE( s << " " << boost::gregorian::to_simple_string(i0) );
  }

}

BOOST_AUTO_TEST_SUITE_END()

---