acsvt0.hpp

Go to the documentation of this file.

#ifndef ACSVT0_
#define ACSVT0_

#include <queue>
#include <boost/algorithm/string/trim.hpp>
#include <boost/tokenizer.hpp>

#include "eleve/config.hpp"

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

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

namespace eepgwde { namespace detail {

  // A two-dimensional multi-array of boost::any.
  //
  // Preserves the original input structure.
  extern DataFrame::ma_any_t frame;

  extern std::string fname0;
  extern std::queue<std::string> fnames;
  extern std::map<std::string, boost::any> results;

  extern std::vector<double> mties0_;
  extern std::vector<double> strikes0_;

  extern eepgwde::detail::Typing::mapping_t bbg_mappings[];

  class CounterA {
  protected:
    double total_;
    int calls_;

  public:
    CounterA() : total_(0.0), calls_(0) {}
    virtual ~CounterA() {}

    virtual bool operator()(record_t & r) {
      return ++calls_ % 2 == 0 ;
    }

    virtual double total() const {
      return total_;
    }

    virtual int calls() const {
      return calls_;
    }
  };

  // Extending the query to use a regular expression.

  struct QPXisc : public CounterA, public DataFrame::Comparor {

    QPXisc(const boost::regex & e) : DataFrame::Comparor(e) {}

    virtual bool is_isc(const std::string& s) {
      return regex_match(s, e, boost::match_partial );
    }

    // For DataFrame::split()
    virtual bool operator()(record_t & r) {
      std::string s( any_cast<std::string>(*r["name"]) );
      return is_isc(s);
    }

    // For std::partition()
    bool compare(DataFrame::Record & r) {
      std::string s( any_cast<std::string>(*r.r_["name"]) );
      return is_isc(s);
    }

  };

}}

namespace {

  using namespace eepgwde::detail;

  // Helper class to split a key into a strike and maturity.
  struct Attr0 : public DataFrame::Record {
    Attr0(DataFrame *df,
      DataFrame::iterator0 itr,
      eepgwde::detail::record_t r) : DataFrame::Record(df, itr, r) {}

    void attributes(const std::string & key0) {
      boost::any o = *r_[key0];
      std::string text = eepgwde::detail::as(o);
      std::string regx(".+ ([0-9.-]+)%[ ]+([0-9]+)Y$");
      // print_captures(regx, text);
      boost::regex e(regx);
      boost::smatch what;
      if (boost::regex_match(text, what, e)) {
    attrs0_.push_back(boost::any(static_cast<std::string>(what[1])));
    attrs0_.push_back(boost::any(static_cast<std::string>(what[2])));
    std::list<boost::any>::iterator a = attrs0_.begin();
    attrs_["strike"] = & * a;
    attrs_["maturity"] = & * (++a);
      }
    }

  };
}


namespace {

  using namespace std;
  using namespace eepgwde::detail;

  struct csv0 {
    static void load0(const std::string & n, DataFrame::ma_any_t & f) {
      char * csv;
      string s1;
      int toks_header = -1; //< columns in the header.
      // We have to count our own lines.
      loader l(n);

      int line=0;

      std::list<boost::any> data;

      while ( csv = l.get() ) {
    string s(csv);

    tokenizer<escaped_list_separator<char> > tok(s);
    tokenizer<escaped_list_separator<char> >::iterator beg;
    int pos=0;

    // A bit of fluff to count the number of tokens/columns.
    for(beg=tok.begin(), pos=1; beg!=tok.end(); ++beg, pos++)
      ;
    int toks_counted = pos;
    if (line == 0 && toks_header < 0) {
      toks_header = toks_counted;
    }

#ifndef NDEBUG
    std::cerr << "(line, line(), toks_counted) : (" 
          << line << ", "
          << l.line() << ", "
          << toks_counted << ") " << endl;
    std::cerr << "line: " << line << ": " << s << endl;
#endif

    if (toks_counted != toks_header) {
      continue;
    }

    for(beg=tok.begin(), pos=1; beg!=tok.end(); ++beg, pos++) {
      data.push_back( boost::any( *beg) );
    }
    line++;
      }

      BOOST_TEST_MESSAGE( "data: " << data.size() << " "
              << toks_header << " "
              << line << " " << l.line());

      int cols0 = toks_header - 1;
      int rows0 = line;

      // Set the array shape - 2d with rows and columns given by the input.
      boost::array<DataFrame::ma_any_t::index, 2> shape ={{ rows0, cols0 }};
      f.resize(shape);
      f.assign(data.begin(), data.end());
    }

    csv0() {
      BOOST_TEST_MESSAGE("QuantLib::frame0::csv0");
    
      int argc = boost::unit_test::framework::master_test_suite().argc;
      char **argv = boost::unit_test::framework::master_test_suite().argv;

#ifndef NDEBUG
      cerr << argc << endl;
      fname0 = std::string(argv[argc-1]);
      cerr << fname0 << endl;
#endif

      for (int i=1; i<argc; i++) {
    cerr << i << " " << argv[i] << endl;
    std::string a(argv[i]);
    fnames.push(a);
      }

#ifndef NDEBUG
      {
    std::queue<std::string> f(fnames);
    while (!f.empty()) {
      std::string a(f.front());
      std::cerr << a << std::endl;
      f.pop();
    }
      }
#endif

      csv0::load0(fname0, frame);
    }

    ~csv0() {}
  };


}

#endif

---