typing1.hpp

Go to the documentation of this file.

#ifndef _TYPING_1
#define _TYPING_1

#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>

#include "eleve/src/typing0.hpp"
#include "eleve/src/scal0.hpp"

namespace eepgwde { namespace detail {


  struct Renderer {

    virtual std::string ys(const boost::any & o) const
      throw (std::domain_error) = 0;

    virtual std::string null() const
      throw (std::domain_error) = 0;

    virtual std::string name() const = 0;

    virtual ~Renderer() {}
  };

  template <typename T>
  struct null0 : public boost::is_object<T>,
         public boost::is_stateless<T>,
         public boost::has_trivial_assign<T>,
         public boost::has_trivial_copy_constructor<T>,
         public boost::has_trivial_default_constructor<T>,
         public virtual Renderer {
    typedef null0<T> type;
    typedef T result_type;

    virtual const result_type operator() () {
      return i0::null1<result_type>();
    }

    virtual operator const boost::any & () const {
      static const result_type a = (null0<result_type>())();
      static const boost::any baa(a);
      return baa;
    }

    virtual std::string name() const {
      static const std::string s = 
    boost::any( i0::null1<result_type>() ).type().name();
      return s;
    }

    virtual bool operator==(const boost::any & b) const {
      static const boost::any ba = *this;
      boost::any bb = b;
      return ba.type() == bb.type();
    }

    virtual bool operator!=(const boost::any & b) const {
      return ! (*this == b);
    }

    std::string ys(const boost::any & o) const
      throw (std::domain_error) {
      static const result_type a = (null0<result_type>())();
      boost::any me = *this;
      if ( me.type() != o.type())
    throw std::domain_error(std::string("null0: ys: mismatch: ") +
                me.type().name() + " " + o.type().name());
      return i0::ys<result_type>(a, o);
    }

    std::string null() const
      throw (std::domain_error) {
      static const result_type a = (null0<result_type>())();
      static const boost::any o(a);
      return i0::ys<result_type>(a, o);
    }

    virtual result_type xs(const std::string & o) const
      throw (std::domain_error) {
      static const result_type a = (null0<result_type>())();
      return i0::xs<result_type>(a, o);
    }

  };


}}

namespace eepgwde { namespace detail {

  namespace i0 {


    template <typename T>
    T * zs0(T *v, const boost::any & o, dummy<0> = 0 )
      throw (std::exception) {
      static const boost::any nullT = (null0<T>())();

      if (o.empty()) return 0;

      if (o.type() == nullT.type()) {
    *v = any_cast<T>(o);
    return v;
      }

      try {
    *v = any_cast<T>(o); 
    return v;
      } catch(const boost::bad_any_cast &) {
      }
      return 0;
    }

    template <typename T>
    T * zs0(T *v, const boost::any & o, dummy<1> = 1 )
      throw (std::exception) {
      static const boost::any nullS = (null0<std::string>())();

      if (o.type() != nullS.type()) {
    return 0;
      }

      std::string s("");
      try {
    s = any_cast<std::string>(o);
    *v = lexical_cast<T>(s);
    return v;
      } catch(const boost::bad_lexical_cast & e0) {
    return 0;
      } catch(const boost::bad_any_cast & e1) {
    std::cerr << "zs0: " << e1.what()
          << " : " << o.type().name() << std::endl;
      }

      return 0;
    }

    template <typename T>
    T * zs0(T *v, const boost::any & o, dummy<2> = 2 )
      throw (std::exception) {
      static const null0<T> nullT = null0<T>();
      static const boost::any nullS = (null0<std::string>())();

      boost::any o1(o);
      if (o1.type() != nullS.type()) {
    // Use the indirection mechanism (via a lookup in types0) to 
    // get a string rendering and pass that on to the next stage.
    Typing::types0_t types0_ = eepgwde::daemon::Q::instance().types0();
    std::string tname = o.type().name();
    Typing::types0_t::const_iterator i = types0_.find(tname);

    if (i == types0_.end()) {
      // throw std::domain_error("unknown type: " + tname);
      return 0;
    }

    Renderer const * p = i->second;

    o1 = boost::any(p->ys(o));
      }

      std::string s("");
      try {
    s = boost::any_cast<std::string>(o1);
    *v = nullT.xs(s);
    return v;
      } catch(const boost::bad_lexical_cast & e0) {
    return 0;
      } catch(const boost::bad_any_cast & e1) {
    std::cerr << "zs0: " << e1.what()
          << " : " << o.type().name() << std::endl;
      }

      return 0;
    }

  }

  template<typename T> T * as(T *v, const boost::any & o)
    throw (std::domain_error) {

    if (!v) return v;

    try {
      if ( i0::zs0<T>(v, o, i0::dummy<0>(0)) )
    return v;

      if ( i0::zs0<T>(v, o, i0::dummy<2>(2)) )
    return v;

    } catch(std::exception & e0) {
      throw std::domain_error(e0.what());
    }
    
    return 0;
  };

  template<typename T> bool is(const boost::any & o)
    throw (std::domain_error) {
    static null0<T> nullT;
    return (nullT == o);
  }

  template <>
  const char ** as<const char *>(const char **v, const boost::any & operand);

  std::string as(const boost::any &o);


}}

namespace eepgwde { namespace detail {


  template<typename T>
  int count(const std::list<boost::any> * values) {
    static null0<T> nullT = null0<T>();
    return std::count_if(values->begin(), values->end(),
             (boost::bind(&null0<T>::operator==,nullT,_1)));
  }
  

}}

namespace eepgwde { namespace detail {


  template<typename T>
  T renderer(const boost::any & o, const T & null_, int fatal)
    throw (const boost::bad_any_cast &) {
    T t;            //< default constructor needed.
    if (as<T>(&t, o)) {
      return t;
    }
    if (fatal) {        //< fake an exception.
      int i = boost::any_cast<int>(boost::any());
    }
    return null_;       //< or give them null.
  }


  template<typename T> 
  std::vector<T> * render(std::vector<T> *r,
              const std::list<boost::any> *l, int & fails,
              const T null_ = (eepgwde::detail::null0<T>())() )
    throw (const boost::bad_any_cast &) {
    fails = l->size();

    if (! (l && r && l->size()) ) return 0;

    int fatal = 0;      //< this flag is for fatal errors.

    fails = fails - count<T>(l);
    r->clear();
    r->resize(l->size(), null_ );
    transform(l->begin(), l->end(),
          r->begin(),
          (boost::bind(&eepgwde::detail::renderer<T>,_1,null_,fatal)));
    return r;
  }


  template<typename T> void
  renderer(boost::any & o, const boost::any & null_,
       int is_overwrite, int fatal)
    throw (const boost::bad_any_cast &) {
    try {
      o = boost::any(renderer<T>(o, (null0<T>())(), 1));
    } catch (const boost::bad_any_cast &e) {
      if (fatal) throw e;
      if (is_overwrite) o = null_;
    }
  }


  template<typename T> 
  std::list<boost::any> * render(std::list<boost::any> *l,
                 int & fails,
                 const boost::any
                 null_ = (eepgwde::detail::null0<boost::any>())() )
    throw (const boost::bad_any_cast &) {
    fails = l->size();
    if (!(l && l->size())) return 0;
    fails = fails - count<T>(l);
    int fatal = 0;
    int is_overwrite = null_.type() != (eepgwde::detail::null0<boost::any>())().type();
    for_each(l->begin(), l->end(),
         (boost::bind(&eepgwde::detail::renderer<T>,_1,null_,is_overwrite,fatal)));
    return l;
  }


}}

#endif

---