typing0.hpp

Go to the documentation of this file.

#ifndef TYPING0_
#define TYPING0_

#include "eleve/config.hpp"

#include <list>
#include <vector>
#include <typeinfo>
#include <iostream>
#include <algorithm>
#include <iomanip>

#include <boost/noncopyable.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/any.hpp>
#include <boost/numeric/conversion/converter.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/lexical_cast.hpp>

#include <boost/date_time/gregorian/gregorian_types.hpp>
#include <boost/date_time/gregorian/formatters.hpp>
#include <boost/date_time/gregorian/parsers.hpp>

#include "eleve/src/runtime2.hpp"

namespace boost { 

  namespace gregorian {
  
  template<class charT>
  inline std::basic_string<charT> to_uk_string_type(const date& d) 
  {
    date::ymd_type ymd = d.year_month_day();
    std::basic_ostringstream<charT> ss;
    ss << std::setw(2) << std::setfill(ss.widen('0')) 
       << ymd.day
       << "-";
    ss << std::setw(2) << std::setfill(ss.widen('0')) 
       << ymd.month.as_number()
       << "-";
    ss << ymd.year ;

    return ss.str();
  }

  inline std::string to_uk_string(const date& d) {
    return to_uk_string_type<char>(d);
  }

  template<class charT>
  inline std::basic_string<charT> to_us_string_type(const date& d) 
  {
    date::ymd_type ymd = d.year_month_day();
    std::basic_ostringstream<charT> ss;
    ss << std::setw(2) << std::setfill(ss.widen('0')) 
       << ymd.month.as_number()
       << "-";
    ss << std::setw(2) << std::setfill(ss.widen('0')) 
       << ymd.day
       << "-";
    ss << ymd.year ;

    return ss.str();
  }
  inline std::string to_us_string(const date& d) {
    return to_us_string_type<char>(d);
  }

}}

namespace eepgwde { namespace detail {


  template <typename T, typename Enable = void>
  struct Numeric { };

  struct is_Numeric {};
  
  template <class T>
  struct Numeric<T, typename enable_if<is_arithmetic<T> >::type> :
    public is_Numeric {
    typedef T value_type;
    T d_;

    Numeric() : d_(0) {}
    Numeric(const T & d) : d_(d) {}
    Numeric(const Numeric & d) : d_(d.d_) {}

    const Numeric operator() () const {
      return Numeric(d_);
    }
    
    operator double () const {
      typedef typename boost::promote<T>::type promoted;
      return boost::numeric::converter<double,promoted>::convert(d_);
    }

    operator std::string () const {
      return boost::lexical_cast<std::string>(d_);
    }

    template <typename U>
    friend std::ostream& operator<< (std::ostream& o,
                     const Numeric<U> & );
    template <typename U>
    friend std::istream& operator>> (std::istream& i,
                     Numeric<U> & );
  };

  template <typename T>
  std::ostream& operator<< (std::ostream& o, const Numeric<T> & t) {
    return o << t.d_;
  }

  template <typename T>
  std::istream& operator>> (std::istream& i, Numeric<T> & t) {
    return i >> t.d_;
  }

  struct usdate : public boost::gregorian::date {
    usdate() : boost::gregorian::date() {}
    usdate(const boost::gregorian::date & d) : boost::gregorian::date(d) {
    }
  };

  std::ostream& operator<< (std::ostream& o, const usdate & t);
  std::istream& operator>> (std::istream& i, usdate & t);

  struct posixdate : public boost::gregorian::date {
    posixdate() : boost::gregorian::date() {}
    posixdate(const boost::gregorian::date & d) : boost::gregorian::date(d) {
    }
  };

  std::ostream& operator<< (std::ostream& o, const posixdate & t);
  std::istream& operator>> (std::istream& i, posixdate & t);

  struct eudate : public boost::gregorian::date {
    eudate() : boost::gregorian::date() {}
    eudate(const boost::gregorian::date & d) : boost::gregorian::date(d) {
    }
  };

  std::ostream& operator<< (std::ostream& o, const eudate & t);
  std::istream& operator>> (std::istream& i, eudate & t);

  template <typename T, int P, int Q>
  struct scaling {
    typedef T scaling_type;
    T scale() const {
      return static_cast<T>(static_cast<T>(P) / static_cast<T>(Q));
    }
  };

  struct rate : public Numeric<double>, public scaling<double, 1, 100> {
    rate() : Numeric<double>(0) {}
    rate(const double & d) : Numeric<double>(d) {}
    rate(const Numeric<double> & d) : Numeric<double>(d.d_) {}
  };

  struct bps : public Numeric<double>, public scaling<double, 1, 100*100> {
    bps() : Numeric<double>(0) {}
    bps(const double & d) : Numeric<double>(d) {}
    bps(const Numeric<double> & d) : Numeric<double>(d.d_) {}
  };


}}

namespace eepgwde { namespace detail {


  template <typename B, typename T>
  struct pointerize0 : public std::unary_function<T, B> {
    B operator()(T & t) {
      return &t;
    }
  };

  template <typename B, typename C>
  B pointerize(C & c) {
    B b(c.size());
    transform(c.begin(), c.end(),
          b.begin(),
          pointerize0<typename B::value_type, typename C::value_type>() );
    return b;
  }

  template <typename B, typename C>
  B pointerize1(C b, C e) {
    B x( distance(b,e) );
    transform(b, e,
          x.begin(),
          pointerize0<typename B::value_type, typename C::value_type>() );
    return x;
  }


  namespace i0 {

    template <int> struct dummy { dummy(int) {} };

  }

}}

#endif

---