csv4.cpp

Go to the documentation of this file.

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

#include "csv4.hpp"

#include <iostream>
#include <stdexcept>

namespace eepgwde { namespace detail {

  const std::string Filter0::strike0_("strike");
  const std::string Filter0::maturity0_("maturity");

  struct Filter0::Impl {
    friend class Filter0;

    Filter0 const * owner;

    std::string service0;

    // Make our own copy to the source frame
    DataFrame::ma_any_t frame_;

    std::auto_ptr<DataFrame> df;

    DataFrame::ma_any_t sorted0;

    Impl(Filter0 const * owner,
     const std::string & service0,
     const DataFrame::ma_any_t & frame) :
      owner(owner), service0(service0), frame_(frame) {
      DataFrame * p = new DataFrame(frame_, service0);
      df = std::auto_ptr<DataFrame>(p);
    }

    ~Impl() {
    }

  };

  Filter0::~Filter0() throw() {
  }

  Filter0::Filter0(const std::string & service0,
           const DataFrame::ma_any_t & frame)
    throw(std::exception) :
    impl(new Impl(this, service0, frame)),
    strike(strike0_), maturity(maturity0_) {
  }

  Filter0::operator DataFrame * () {
    return impl->df.get();
  }

  void Filter0::add0(std::vector<DataFrame::Record *> & s) {
    // Create records to hold the new attributes
    std::list<record_t *> attrs;
    back_insert_iterator< std::list<record_t *> > ii(attrs);
    transform(s.begin(), s.end(),
          ii,
          boost::bind(&DataFrame::Record::attrs,_1));

    // Create a new Impl to carry the new frame.
    // This uses the the records with the new attributes.
    DataFrame::ma_any_t xframe1;
    impl->df->add(&xframe1, s);
    Impl * p = new Impl(this, impl->service0, xframe1);
    impl = std::auto_ptr<Impl>(p);
  }

  DataFrame::ma_any_t
  Filter0::partition(DataFrame::Comparor & comparor) {
    DataFrame::payloader payload1(*impl->df);

    std::vector<DataFrame::Record> sort0 = payload1;

    std::vector<DataFrame::Record>::iterator mark =
      std::partition(sort0.begin(), sort0.end(),
             boost::bind(&DataFrame::Comparor::compare,
                 boost::ref(comparor),_1) );

    std::vector<DataFrame::Record>::iterator mark0 = sort0.begin();
    if (mark != sort0.end() && mark != sort0.begin() ) {
      mark0 = mark;
    }

    BOOST_ASSERT(distance(sort0.begin(), mark0) > 1);

    // Using the mark.

    // second key
    sort(sort0.begin(), mark0,
     boost::bind(std::less<int>(),
             boost::bind(&DataFrame::Record::as<int>,_1, maturity),
             boost::bind(&DataFrame::Record::as<int>,_2, maturity) ));

    // first key
    stable_sort(sort0.begin(), mark0,
        boost::bind(std::less<double>(),
                boost::bind(&DataFrame::Record::as<double>,_1, strike),
                boost::bind(&DataFrame::Record::as<double>,_2, strike) ));

    int headings = 1; //< replace header names with ours.
    DataFrame::ma_any_t sorted00 = payload1.as(sort0.begin(), mark0, headings);

    // Because sorted0 was default-constructed, the shape won't match
    // its assignee.
    boost::array<DataFrame::ma_any_t::index, 2> shape =
      {{ sorted00.shape()[0], sorted00.shape()[1] }};
    return sorted00;
  }

}}

---