runtime2.cpp

Go to the documentation of this file.

#include "eleve/config.hpp"

#include <limits>
#include <string>
#include <locale>
#include <locale.h>

#include <boost/array.hpp>
#include <boost/lexical_cast.hpp>

#include "runtime2.hpp"
#include "typing0.hpp"

#include "typing3.hpp"

#include "typing1.hpp"

#include <ql/utilities/tracing.hpp>

#include <iostream>

namespace eepgwde { namespace detail {

  static std::vector<Renderer const *> null_types;

  typedef struct type_t {
    std::string name0;
    Renderer * p;
  } type_t;

#if 0

  
  static Renderer * s_0(new null0<std::string>());

  static Renderer * ch_0(new null0<char>());
  static Renderer * uch_0(new null0<unsigned char>());
  static Renderer * sh_0(new null0<short>());
  static Renderer * ush_0(new null0<unsigned short>());

  static Renderer * usdt_0(new null0<usdate>());
  static Renderer * eudt_0(new null0<eudate>());
  static Renderer * psxdt_0(new null0<posixdate>());

  static Renderer * i_0(new null0<int>());
  static Renderer * ul_0(new null0<unsigned long>());
  static Renderer * l_0(new null0<long>());
  static Renderer * ll_0(new null0<long long>());
  static Renderer * ull_0(new null0<unsigned long long>());

  static Renderer * d_0(new null0<double>());
  static Renderer * ld_0(new null0<long double>());
  static Renderer * f_0(new null0<float>());

  static Renderer * rate_0(new null0<rate>());
  static Renderer * bps_0(new null0<bps>());

  type_t types_0[] = {
    { psxdt_0->name(), psxdt_0 },
    { usdt_0->name(), usdt_0 },
    { eudt_0->name(), eudt_0 },
    { s_0->name(), s_0 },
    { ch_0->name(), ch_0 },
    { uch_0->name(), uch_0 },
    { sh_0->name(), sh_0 },
    { ush_0->name(), ush_0 },
    { i_0->name(), i_0 },
    { ul_0->name(), ul_0 },
    { l_0->name(), l_0 },
    { ll_0->name(), ll_0 },
    { ull_0->name(), ull_0 },
    { f_0->name(), f_0 },
    { ld_0->name(), ld_0 },
    { d_0->name(), d_0 },
    { rate_0->name(), rate_0 },
    { bps_0->name(), bps_0 }
  };
  #else
  type_t types_0[] = {};
#endif

  static std::vector<type_t>
  types_1(types_0,
      types_0 + (sizeof(types_0)/sizeof(types_0[0])));

  class Typing::Impl {
  public:
    Typing::mappings_t mappings;
    Typing::types0_t types0;

    Impl() throw() {
      for(std::vector<type_t>::iterator i=types_1.begin();
      i!=types_1.end(); ++i) {
    types0[i->name0] = i->p;
      }
    }

    ~Impl() throw() {}
    Typing *owner; 
  };

  Typing::Typing() throw(std::exception) :
    impl(new Typing::Impl) {
    impl->owner = this;
  }

  Typing::~Typing() throw(std::exception) {}

  Typing::types0_t & Typing::types0() {
    return impl->types0;
  }

  Renderer const * Typing::add(Renderer *p) {
    std::string s = p->name();
    types0_t::const_iterator i;
    if ( (i = impl->types0.find(s)) != impl->types0.end())
      return i->second;

    impl->types0[s] = p;
    return p;
  }

  Typing::mappings_t & Typing::mappings() {
    return impl->mappings;
  }

  void Typing::mappings(const Typing::mapping_t p[]) {
    for (int i=0; p[i].old_.size() > 0; i++) {
      impl->mappings[ p[i].old_ ] = p[i].new_;
    }
  }

  const locale Typing::posix = locale(locale::classic(), locale("POSIX"), locale::time);
  const locale Typing::us = locale(locale::classic(), locale("en_US"), locale::time);
  const locale Typing::uk = locale(locale::classic(), locale("en_GB"), locale::time);

  typedef boost::array<const std::locale, 3> locales_t;
  static locales_t locales = { Typing::posix, Typing::us, Typing::uk };    

  const locale * dating(const std::locale & ours) {
    locale ours0 = locale(locale::classic(), ours, locale::time);

    locales_t::iterator theirs;
    if ( (theirs = find(locales.begin(), locales.end(), ours0) ) != locales.end() )
      return & *theirs;
    return 0;
  }
    
  void Typing::set(const std::locale & ours) throw (std::domain_error) {
    locale loc0 = locale();
    locale loc2 = locale(loc0, ours, locale::time);
    locale::global(loc2);
  }

  const std::locale & Typing::get() throw (std::domain_error) {
    locale ours = locale();
    const locale * p;
    if ( (p = dating(ours) ))
      return *p;
    throw std::domain_error("unknown locale");
  }

  boost::gregorian::date locale_trier(const std::string & sdt) throw (std::domain_error) {

    static boost::gregorian::date bdt(boost::gregorian::not_a_date_time);

    boost::gregorian::date psxdt(bdt);
    try {
      psxdt = boost::gregorian::from_simple_string(sdt);
    } catch (...) {
    }

    boost::gregorian::date usdt(bdt);
    try {
      usdt = boost::gregorian::from_us_string(sdt);
    } catch (...) {
    }

    boost::gregorian::date ukdt(bdt);
    try {
      ukdt = boost::gregorian::from_uk_string(sdt);
    } catch (...) {
    }

    const locale * known = dating(locale());

    if (known && *known == Typing::posix) {
      return psxdt;
    }

    if (known && *known == Typing::uk) {
      return ukdt;
    }

    if (known && *known == Typing::us) {
      return usdt;
    }

    // No locale recognised so guess
    if (psxdt != bdt && usdt == bdt && ukdt == bdt) return psxdt;
    if (psxdt == bdt && usdt != bdt && ukdt == bdt) return usdt;
    if (psxdt == bdt && usdt == bdt && ukdt != bdt) return ukdt;

    throw std::domain_error("unknown locale");

    return bdt;
  }

  template <>
  const char ** as<const char *>(const char **v, const boost::any & operand)
  {
    try {
      *v = any_cast<const char *>(operand);
      return v;
    } catch(const boost::bad_any_cast &) {
      ;
    }
    return 0;
  }


  std::string as(const boost::any & operand) {
    std::string result("");

    if (operand.empty()) return result;

    if (as(&result, operand))
      return result;

    int iresult;
    if (as(&iresult, operand))
      return lexical_cast<std::string>(iresult);

    {
      rate dresult;
      if (as(&dresult, operand)) {
    return lexical_cast<std::string>(dresult);
      }
    }

    {
      bps dresult;
      if (as(&dresult, operand))
    return lexical_cast<std::string>(dresult);
    }

    {
      double dresult;
      if (as(&dresult, operand))
    return lexical_cast<std::string>(dresult);
    }

    {
      std::string dresult;
      if (as(&dresult, operand))
    return lexical_cast<std::string>(dresult);
    }

    {
      posixdate dtresult;
      if (as(&dtresult, operand))
    return lexical_cast<std::string>(dtresult);
    }

    {
      usdate dtresult;
      if (as(&dtresult, operand))
    return lexical_cast<std::string>(dtresult);
    }

    {
      eudate dtresult;
      if (as(&dtresult, operand))
    return lexical_cast<std::string>(dtresult);
    }

    return result;
  }

  std::string Typing::as(const boost::any & operand) const
    throw (std::exception) {
    return eepgwde::detail::as(operand);
  }

  std::ostream& operator<< (std::ostream& o, const usdate & t) {
    std::string s = boost::gregorian::to_us_string(t);
    return o << s;
  }

  std::istream& operator>> (std::istream& i, usdate & t) {
    std::string s; 
    i >> s;
    t = boost::gregorian::from_us_string(s);
    return i;
  }

  std::ostream& operator<< (std::ostream& o, const eudate & t) {
    std::string s = boost::gregorian::to_uk_string(t);
    return o << s;
  }

  std::istream& operator>> (std::istream& i, eudate & t) {
    std::string s; 
    i >> s;
    t = boost::gregorian::from_uk_string(s);
    return i;
  }

  std::ostream& operator<< (std::ostream& o, const posixdate & t) {
    std::string s = boost::gregorian::to_simple_string(t);
    return o << s;
  }

  std::istream& operator>> (std::istream& i, posixdate & t) {
    std::string s; 
    i >> s;
    try {
      t = boost::gregorian::from_simple_string(s);
    } catch (...) {
      t = boost::gregorian::from_undelimited_string(s);
    }
    return i;
  }

}}

---