csv1.cpp

Go to the documentation of this file.

#include "eleve/src/typing3.hpp"
#include "eleve/src/typing1.hpp"

#include "csv1.hpp"
#include "csv5.hpp"

#include <iostream>
#include <stdexcept>

#if defined(CSV1_NOGEN)

namespace {
  using namespace eepgwde::detail;
  
  fn1_ref_t render_dt(&eepgwde::detail::DataFrame::render<posixdate>);
  fn1_ref_t render_usdt(&eepgwde::detail::DataFrame::render<usdate>);
  fn1_ref_t render_eudt(&eepgwde::detail::DataFrame::render<eudate>);

  fn1_ref_t render_s(&eepgwde::detail::DataFrame::render<std::string>);
  fn1_ref_t render_i(&eepgwde::detail::DataFrame::render<int>);

  fn1_ref_t render_d(&eepgwde::detail::DataFrame::render<double>);
  fn1_ref_t render_rate(&eepgwde::detail::DataFrame::render<rate>);
  fn1_ref_t render_bps(&eepgwde::detail::DataFrame::render<bps>);

#ifndef NDEBUG
  fn1_ref_t simple_i(&eepgwde::detail::DataFrame::simple<int>);
  fn1_ref_t simple_d(&eepgwde::detail::DataFrame::simple<double>);
#endif

}

namespace eepgwde { namespace detail {
  // BEGIN : generated

  // Normally, this data is generated, but, when developing, I use these static versions.

  static render0_t render0s_[] = {
    { std::string("N7eepgwde6detail9posixdateE"), &render_dt },
    { std::string("Ss"), &render_s },
    { std::string("d"), &render_d },
    { std::string("i"), &render_i },
    { std::string(), 0 }
  };

  static col_t defaults_attrs[] = {
    { std::string("PX_BID"), std::string("d") },
    { std::string("PX_ASK"), std::string("d") },
    { std::string("PX_LAST"), std::string("d") },
    { std::string(""),  std::string("") }
  };

  static col_t eurisc_attrs[] = {
    { std::string("PX"), std::string("Ss") },
    { std::string("X0"), std::string("Ss") },
    { std::string("X1"), std::string("d") }, 
    { std::string("X2"), std::string("i") },
    { std::string(""), std::string("") }
  };

  static col_overrides_t overrides_attrs[] = {
    { std::string("eurisc"), eurisc_attrs }
  };

  // END : generated 
}}
#endif

namespace eepgwde { namespace detail {

#if !defined(CSV_NOGEN)
  extern col_t defaults_attrs[];
  extern render0_t render0s_[];
  extern col_overrides_t overrides_attrs[];
#endif 

  struct DataFrame::Impl {
    friend class DataFrame;

    int counter;

    const std::string overrides0;

    map_t defaults;

    render0_map_t renderers;

    map_overrides_t moverrides;

    map_t overrides;

    Typing::types0_t types0;

    //
    Impl(const std::string & overrides0_) :
      counter(0), overrides0(overrides0_), types0(Typing().types0()) {

      for (int i=0; render0s_[i].p; i++)
    renderers[ render0s_[i].name0 ] = render0s_[i].p;

      for (int i=0; defaults_attrs[i].old_.size() > 0; i++)
    defaults[ defaults_attrs[i].old_ ] = defaults_attrs[i].new_;

      for (int i=0; overrides_attrs[i].p; i++)
    moverrides[ overrides_attrs[i].name0 ] = overrides_attrs[i].p;

      map_overrides_t::const_iterator i;
      if ( (i=moverrides.find(overrides0)) != moverrides.end()) {
    col_t * overrides_attrs = i->second;
    for (int i=0; overrides_attrs[i].old_.size() > 0; i++)
      overrides[ overrides_attrs[i].old_ ] = overrides_attrs[i].new_;
      }
    }
    
  };

  DataFrame::~DataFrame() throw() { }

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

  Typing::types0_t::value_type DataFrame::column_t0(int position0) 
    throw (std::out_of_range) {
    std::string s("index: " +  boost::lexical_cast<std::string>(position0) );

    l_itr i = header.left.find(position0);
    if (i == header.left.end()) throw std::out_of_range(s);
    
    return this->column_t0(i->second);
  }

  Typing::types0_t::value_type DataFrame::column_t0(const std::string colname0)
    throw (std::domain_error) {
    map_t::iterator render0;
    std::string s("index: ");
    s += colname0;

    if ( (render0 = impl->overrides.find(colname0)) == impl->overrides.end() )
      if ( (render0 = impl->defaults.find(colname0)) == impl->defaults.end() )
    throw std::domain_error(s);

    Typing::types0_t::iterator p;
    if ( (p = impl->types0.find(render0->second)) == impl->types0.end() )
      throw std::domain_error(s);

    return *p;
  }

  DataFrame::payload_t init0(DataFrame::ma_any_t & frame_) {
    if (frame_.shape()[0] == 0 &&
    frame_.shape()[1] == 0)
      return frame_[ boost::indices[DataFrame::range()][DataFrame::range()] ];

    return frame_[ boost::indices[DataFrame::range().start(1)][DataFrame::range()] ];    
  }

  //

  DataFrame::DataFrame(ma_any_t & frame_,
               std::string overrides0)
    throw(std::domain_error) :
    frame(frame_), impl(new Impl(overrides0)),
    payload( new payload_t(init0(frame_)) ) {

      if (frame_.shape()[0] == 0 &&
      frame_.shape()[1] == 0) return;

      payload_t myview =
    frame[ boost::indices[range() <= 0][range()] ];

      DataFrame::ma_any_t::size_type rows0 = myview.shape()[0];
      DataFrame::ma_any_t::size_type cols0 = myview.shape()[1];

      for (DataFrame::ma_any_t::size_type i = 0; i < rows0; ++i) {
    for (DataFrame::ma_any_t::size_type j = 0; j < cols0; ++j) {
      std::string name0(boost::any_cast<std::string>(myview[i][j]));
      header.insert( DataFrame::attr_pos_t::value_type(j, name0 )); 
    }
      }
    }

  DataFrame & DataFrame::operator=(const DataFrame & t) {
    if (this != &t) {
      boost::array<DataFrame::ma_any_t::index, 2>
    shape ={{ t.frame.shape()[0], t.frame.shape()[1] }};
      frame.resize(shape);
      frame = t.frame;
      std::auto_ptr<Impl> impl0(new Impl(t.impl->overrides0));
      impl = impl0;
      header = t.header;
      payload_t * p = new DataFrame::payload_t(*t.payload);
      payload = boost::shared_ptr<DataFrame::payload_t>(p);
    }
    return *this;
  }

  DataFrame::DataFrame(const DataFrame & df) throw(std::domain_error) :
    frame(df.frame), impl(new Impl(df.impl->overrides0)),
    payload( new DataFrame::payload_t(init0(frame)) ),
    header(df.header) {
  }

  DataFrame::DataFrame(DataFrame & df) throw(std::domain_error)  :
    frame(df.frame), impl(new Impl(df.impl->overrides0)),
    payload( new DataFrame::payload_t(init0(frame)) ),
    header(df.header) {
  }

  const std::string & DataFrame::overrides() const {
    return impl->overrides0;
  }

  DataFrame::column_t
  DataFrame::column(int position0)
    throw (std::out_of_range) {
    try {
      DataFrame::column_t myview =
    (*payload)[ boost::indices[range()][position0] ];
      return myview;
    } catch (std::exception & e) {
      std::string s("index: ");
      s += boost::lexical_cast<std::string>(position0);
      throw std::out_of_range(s);
    }
  }

  DataFrame::column_t
  DataFrame::column(const std::string name0)
    throw (std::domain_error) {
    std::string s("index: ");
    s += name0;

    DataFrame::r_itr a = header.right.find(name0);
    if (a != header.right.end()) {
      ;
    } else {
      throw std::domain_error(s);
    }
    try {
      return column(a->second);
    } catch (std::out_of_range & e) {
      throw std::domain_error(s);
    }
    eepgwde::daemon::watcher = 4;
    return column(0);       
  }

  void DataFrame::render(const std::string colname0) throw(std::domain_error) {
    map_t::iterator render0;
    std::string s("index: ");
    s += colname0;

    if ( (render0 = impl->overrides.find(colname0)) == impl->overrides.end() )
      if ( (render0 = impl->defaults.find(colname0)) == impl->defaults.end() )
    throw std::domain_error(s);

    render0_map_t::iterator p = impl->renderers.find(render0->second);

    if (p == impl->renderers.end())
      throw std::domain_error("no render function defined for " + s);

    (*(p->second))(*this, colname0);
    
    return;
  }

  //
  void DataFrame::render() throw(std::domain_error) {
    DataFrame::r_itr n0;
    std::domain_error e1("");
    bool fail = 0;
    
    for(n0 = header.right.begin();
    n0 != header.right.end(); ++n0) {
      try {
    render(n0->first);
      } catch (std::domain_error & e) {
    e1 = e;
    fail = 1;
      }
    }

    if (fail) {
      throw e1;
    }
  }

  //
  DataFrame::ma_any_t * DataFrame::add(ma_any_t * result) {
    std::list<boost::any> data0;

    int rows0 = frame.shape()[0];
    int cols0 = frame.shape()[1];

    for (iterator0 i = frame.begin(); i != frame.end(); ++i) {
      for(iterator1 ii = (*i).begin(); ii != (*i).end(); ++ii) {
    data0.push_back(*ii);
      }
    }

    for (int i=0; i<=cols0; i++)
      data0.push_back(boost::any());

    boost::array<DataFrame::ma_any_t::index, 2> shape0 ={{ rows0 + 1, cols0 }};

    result->resize(shape0);
    result->assign(data0.begin(), data0.end());

    return result;
  }

  //
  DataFrame::ma_any_t * DataFrame::add(DataFrame::ma_any_t * result,
                       const std::string & name0) {
    std::list<boost::any> data0;

    int rows0 = frame.shape()[0];
    int cols0 = frame.shape()[1];

    for (iterator0 i = frame.begin(); i != frame.end(); ++i) {
      for(iterator1 ii = (*i).begin(); ii != (*i).end(); ++ii) {
    data0.push_back(*ii);
      }
      if (i == frame.begin())
    data0.push_back(boost::any(name0));
      else
    data0.push_back(boost::any());
    }

    boost::array<DataFrame::ma_any_t::index, 2> shape0 ={{ rows0, cols0 + 1 }};

    result->resize(shape0);
    result->assign(data0.begin(), data0.end());

    return result;
  }

  //
  DataFrame::ma_any_t * DataFrame::add(DataFrame::ma_any_t * result,
                       const std::set<std::string> & name0) {
    std::list<boost::any> data0;

    int rows0 = frame.shape()[0];
    int cols0 = frame.shape()[1];

    for (iterator0 i = frame.begin(); i != frame.end(); ++i) {
      for(iterator1 ii = (*i).begin(); ii != (*i).end(); ++ii) {
    data0.push_back(*ii);
      }
      if (i == frame.begin()) {
    for(std::set<std::string>::const_iterator i=name0.begin();
        i != name0.end(); ++i)
      data0.push_back(boost::any(*i));
      }
      else {
    for(std::set<std::string>::const_iterator i=name0.begin();
        i != name0.end(); ++i)
      data0.push_back(boost::any());
      }
    }

    boost::array<DataFrame::ma_any_t::index, 2>
      shape0 ={{ rows0, cols0 + name0.size() }};

    result->resize(shape0);
    result->assign(data0.begin(), data0.end());

    return result;
  }

  struct Collector {
    std::set<std::string> names;

    void collect(const record_t * r) {
      for(record_t::const_iterator i=r->begin();
      i != r->end(); ++i) {
    names.insert(i->first);
      }
    }
  };

  //
  DataFrame::ma_any_t *
  DataFrame::add(DataFrame::ma_any_t * result,
         const std::vector<DataFrame::Record *> & xtra,
         std::set<std::string> name0) {
    std::list<boost::any> data0;

    if (! name0.size() > 0) {
      std::list<record_t *> attrs;
      back_insert_iterator< std::list<record_t *> > ii(attrs);
      transform(xtra.begin(), xtra.end(),
        ii,
        boost::bind(&DataFrame::Record::attrs,_1));

      Collector c;
      for_each(attrs.begin(), attrs.end(),
           boost::bind(&Collector::collect,boost::ref(c),_1));

      name0 = c.names;
    }

    if (! name0.size() > 0) return 0;

    int rows0 = frame.shape()[0];
    int cols0 = frame.shape()[1];

    std::vector<DataFrame::Record *>::const_iterator
      ix = xtra.begin();

    for (iterator0 i = frame.begin(); i != frame.end(); ++i) {
      for(iterator1 ii = (*i).begin(); ii != (*i).end(); ++ii) {
    data0.push_back(*ii);
      }
      if (i == frame.begin()) {
    for(std::set<std::string>::const_iterator i=name0.begin();
        i != name0.end(); ++i)
      data0.push_back(boost::any(*i));
      }
      else {
    DataFrame::Record * r = *ix;
    record_t & r0 = r->attrs_; 
    for(std::set<std::string>::const_iterator i=name0.begin();
        i != name0.end(); ++i) {
      data0.push_back( * r0[*i] );
    }
    ++ix;
      }
    }

    boost::array<DataFrame::ma_any_t::index, 2>
      shape0 ={{ rows0, cols0 + name0.size() }};

    result->resize(shape0);
    result->assign(data0.begin(), data0.end());

    return result;
  }

  DataFrame::columnar::operator std::list<boost::any>() {
    std::list<boost::any> result(view_.size());
    copy(view_.begin(), view_.end(), result.begin());
    return result;
  }

  DataFrame::rowar::operator std::list<boost::any>() {
    std::list<boost::any> data0;
    for(iterator1 ii = (*view_).begin(); ii != (*view_).end(); ++ii) {
      data0.push_back(*ii);
    }
    return data0;
  }

  DataFrame::rowar::operator record_t () {
    record_t m;

    DataFrame::iterator1 ii;
    DataFrame::l_itr lhi;
    for(ii = (*view_).begin(), lhi = owner_->header.left.begin();
    ii != (*view_).end() && lhi != owner_->header.left.end();
    ++ii, ++lhi) {
      m[lhi->second] = &(*ii);
    }
    return m;
  }

  DataFrame::ma_any_t
  DataFrame::payloader::as0(std::vector< DataFrame::Record * > & r,
                int headings) {
    std::list<boost::any> data;
    int rows0 = 0, cols0 = 0;
    rows0 = r.size();
    cols0 = df_.frame.shape()[1];

    if (!headings) {
      DataFrame::iterator0 ir = df_.frame.begin();
      for (DataFrame::iterator1 cr = ir->begin();
       cr != ir->end(); ++cr) {
    data.push_back(*cr);
      }
    } else {
      for(DataFrame::l_itr i=df_.header.left.begin();
      i != df_.header.left.end(); ++i) {
    data.push_back( boost::any( i->second ) );
      }
    }

    for (std::vector<DataFrame::Record *>::iterator i = r.begin();
     i != r.end(); ++i) {
      DataFrame::iterator0 ir = (*i)->itr_;
      for (DataFrame::iterator1 cr = ir->begin();
       cr != ir->end(); ++cr) {
    data.push_back(*cr);
      }
    }

    boost::array<DataFrame::ma_any_t::index, 2> shape1 ={{ rows0 + 1, cols0 }};
    ma_any_t t(shape1);
    t.assign(data.begin(), data.end());

    return t;
  }

  DataFrame::headar::operator DataFrame::attr_pos_t () const {
    DataFrame::attr_pos_t::right_map::iterator ri;
    attr_pos_t h0(owner_->header);
    
    for(Typing::mappings_t::const_iterator i = mappings.begin();
    i != mappings.end(); ++i) {
      if ( (ri = h0.right.find(i->first)) != h0.right.end() ) {
    bool changed =
      h0.right.replace_key(ri, i->second);
      }
    }

    return h0;
  }
  
  static std::ostream & dumper(std::ostream & o,
                   DataFrame::ma_any_t & frame) {
    for (DataFrame::iterator0 i = frame.begin(); i != frame.end(); ++i) {
      for(DataFrame::iterator1 ii = (*i).begin(); ii != (*i).end(); ++ii) {
    o << (*ii).type().name() << " " << as(*ii) << " ";
      }
      o << std::endl;
    }
    return o;
  }

  std::ostream& operator<< (std::ostream& o, DataFrame::ma_any_t & frame) {
    return dumper(o, frame);
  }

  std::ostream& operator<< (std::ostream& os,
                const eepgwde::detail::DataFrame::attr_pos_t::left_map & l) {
    for(DataFrame::l_itr i = l.begin(); i != l.end(); ++i)
      os << i->first << " <--> " << i->second << "\n";
    return os;
  }

#ifndef NDEBUG
  int DataFrame::counter() const {
    return impl->counter++;
  }

  void call(DataFrame & df) {
    col_t t;
    df.render("PX");
    df.render("X1");
    df.render("PX_ASK");
  }
#endif

}}

---