csv1.hpp

Go to the documentation of this file.

#ifndef CSV1_
#define CSV1_

#include "eleve/config.hpp"

#include <string>
#include <map>
#include <list>
#include <set>
#include <string>
#include <stdexcept>

#include <boost/bimap.hpp>
#include <boost/any.hpp>
#include <boost/multi_array.hpp>
#include <boost/function.hpp>
#include <boost/regex.hpp>

#include "eleve/src/typing0.hpp"

namespace eepgwde { namespace detail { 


  typedef std::map<std::string, boost::any *> record_t;

  class DataFrame {
  public:

    enum part_t { ROW, COLUMN };

    typedef boost::bimap<int, std::string> attr_pos_t;

    typedef attr_pos_t::left_map::const_iterator l_itr;

    typedef attr_pos_t::right_map::const_iterator r_itr;

    typedef boost::multi_array_types::index_range range;
    typedef boost::multi_array<boost::any, 2> ma_any_t;

    typedef ma_any_t::array_view<2>::type payload_t;

    typedef ma_any_t::array_view<1>::type column_t;

    typedef payload_t::iterator iterator0;
    typedef column_t::iterator iterator1;

    attr_pos_t header;

    ma_any_t & frame;

    column_t column(const std::string name0)
      throw (std::domain_error);

    column_t column(int position0)
      throw (std::out_of_range);

    Typing::types0_t::value_type column_t0(int position0)
      throw (std::out_of_range);

    Typing::types0_t::value_type column_t0(const std::string name0)
      throw (std::domain_error);

    Typing::types0_t & types0();

    template <typename T>
    void render(column_t & view0,
        const boost::any
        null_ = (eepgwde::detail::null0<boost::any>())() )
      throw(std::domain_error) {
      for (iterator1 i = view0.begin(); i != view0.end(); ++i) {
    renderer<T>(*i, null_, 1, 0);
      }
    }

    template <typename T>
    void render(const std::string colname0)
      throw(std::domain_error) {
      column_t myview = this->column(colname0);
      this->render<T>(myview);
    }

    void render(const std::string colname0) throw(std::domain_error);

    void render() throw(std::domain_error);

    explicit DataFrame(ma_any_t & frame_,
               std::string overrides0 = std::string(""))
      throw(std::domain_error);

    const std::string & overrides() const;

    DataFrame(const DataFrame & df) throw(std::domain_error);
    DataFrame(DataFrame & df) throw(std::domain_error);

    DataFrame & operator=(const DataFrame & t);

    ma_any_t * add(ma_any_t *);

    ma_any_t * add(DataFrame::ma_any_t *, const std::string & name0);

    ma_any_t * add(DataFrame::ma_any_t *,
           const std::set<std::string> & names);

    virtual ~DataFrame() throw();

    #ifndef NDEBUG

    int counter() const;

    template <typename T>
    void simple(column_t & view0,
        const boost::any
        null_ = (eepgwde::detail::null0<boost::any>())() )
      throw(std::domain_error) {
      for (iterator1 i = view0.begin(); i != view0.end(); ++i) {
    std::cerr << counter() << " "
          << (*i).type().name()
          << std::endl;
      }
      eepgwde::daemon::watcher = 1;
    }

    template <typename T>
    void simple(std::string colname0) throw(std::domain_error) {
      DataFrame::column_t myview = this->column(colname0);
      simple<T>(myview);
    }

    #endif


    struct columnar {
      const DataFrame::column_t & view_;
      columnar(DataFrame::column_t & view) :
    view_(view) {};
      columnar(const DataFrame::column_t & view) :
    view_(view) {};

      operator std::list<boost::any> ();

      template <typename T>
      operator std::vector<T> () {
    std::vector<T> r;
    std::list<boost::any> l(*this);
    int fails=0;

    r = * eepgwde::detail::render<T>(&r, &l, fails);
    return r;
      }
    };

    struct columnar1 : public columnar {
      columnar1(DataFrame::column_t & view) :
    columnar(view) {};
      columnar1(const DataFrame::column_t & view) :
    columnar(view) {};

      template <typename T>
      operator std::vector<T> () {
    std::vector<T> r = columnar(*this);
    sort(r.begin(), r.end());
    return std::vector<T>(r.begin(), unique(r.begin(), r.end()));
      }
    };

    struct rowar {
      iterator0 view_;
      const DataFrame * owner_;
      rowar(const DataFrame * owner, iterator0 view) :
    owner_(owner), view_(view) {};

      operator std::list<boost::any> ();
      operator record_t ();
    };

    struct headar : public rowar {
      const Typing::mappings_t & mappings;

      headar(const DataFrame * owner,
         const Typing::mappings_t & mappings) :
    rowar(owner, owner->frame.begin() ), mappings(mappings) {}

      operator attr_pos_t () const;

    };

    struct Record {
      mutable DataFrame *df_;
      mutable DataFrame::iterator0 itr_;
      mutable eepgwde::detail::record_t r_;
      std::list<boost::any> attrs0_;
      record_t attrs_;

      Record(DataFrame *df,
         DataFrame::iterator0 itr,
         eepgwde::detail::record_t r) : df_(df), itr_(itr), r_(r) {}

      template <typename T>
      T as(const std::string & key) const throw (std::domain_error & ) {
    T r0;
    boost::any o = *(r_)[key];
    if (!eepgwde::detail::as<T>(&r0, o)) {
      eepgwde::daemon::watcher = 1;
      std::string mesg("as: failed: " + key + " " + o.type().name() );
      throw std::domain_error(mesg);
    }
    return r0;
      }

      record_t * attrs() {
    return &attrs_;
      }

      virtual void attributes(const std::string &) {
    return;
      }
    };

    struct Comparor {
      const boost::regex & e;
      Comparor(const boost::regex & e) : e(e) {}

      virtual bool compare(DataFrame::Record & r)  = 0;
    };

    ma_any_t * add(DataFrame::ma_any_t *,
           const std::vector<Record *> & xtra_attrs,
           std::set<std::string> names = std::set<std::string>());

    struct payloader {
      DataFrame & df_;

      payloader(DataFrame & df) : df_(df) {}

      operator std::vector<DataFrame::iterator0> () {
    std::vector<DataFrame::iterator0> result;

    for (DataFrame::iterator0 i=df_.payload->begin();
         i != df_.payload->end(); ++i)
      result.push_back(i);
    
    return result;
      }

      operator std::vector<eepgwde::detail::record_t> () {
    std::vector<eepgwde::detail::record_t>
      result;

    for (DataFrame::iterator0 i=df_.payload->begin();
         i != df_.payload->end(); ++i) {
      eepgwde::detail::record_t r = DataFrame::rowar(&df_, i);
      result.push_back(r);
    }
    return result;
      }

      //
      template <typename T>
      operator std::vector<T> () {
    std::vector<T> result;

    for (DataFrame::iterator0 i=df_.payload->begin();
         i != df_.payload->end(); ++i) {
      eepgwde::detail::record_t r = DataFrame::rowar(&df_, i);
      result.push_back( T(&df_, i, r) );
    }
    return result;
      }

      template <typename T>
      DataFrame::ma_any_t
      as(T b0, T e0, int headings=0) {
    std::vector<typename T::value_type> r(b0, e0);
    std::vector<DataFrame::Record * > s =
      pointerize<std::vector< DataFrame::Record *>, std::vector<typename T::value_type> >(r);

    DataFrame::ma_any_t sorted0 = as0(s, headings);
    return sorted0;
      }

      template <typename T>
      DataFrame::ma_any_t
      as(std::vector<T> & r, int headings=0) {
    std::vector<DataFrame::Record * > s =
      pointerize<std::vector< DataFrame::Record *>, std::vector<T> >(r);
    return as0(s, headings);
      }

      DataFrame::ma_any_t
      as0(std::vector< DataFrame::Record * > & r, int headings);

    };

    boost::shared_ptr<eepgwde::detail::DataFrame::payload_t> payload;

    class Impl;
    friend class Impl;

  protected:
    std::auto_ptr<eepgwde::detail::DataFrame::Impl> impl;
  };

  std::ostream& operator<< (std::ostream& os,
                const eepgwde::detail::DataFrame::attr_pos_t::left_map & l);

  //
  std::ostream& operator<< (std::ostream& o,
                eepgwde::detail::DataFrame::ma_any_t & frame);


  #ifndef NDEBUG
  // Debug invocation: trace call
  void call(DataFrame & df);
  #endif

}}

#endif

---