runtime0.cpp

Go to the documentation of this file.

#include "eleve/config.hpp"

#include <map>
#include <string>
#include <set>
#include <iostream>
#include <fstream>
#include <stdexcept>

#include "scal0.hpp"

#include "weekdays0.hpp"
#include "mismatch.cpp"

#include <boost/filesystem.hpp>

#include <boost/foreach.hpp>
#include <boost/date_time/gregorian/gregorian.hpp> 
#include <boost/algorithm/string/replace.hpp>

#include <ql/utilities/tracing.hpp>
#include <ql/time/calendars/jointcalendar.hpp>
#include <ql/time/calendars/bespokecalendar.hpp>


namespace QuantLib {

  struct NCalendar : public Calendar {
    NCalendar(Calendar & cal) : Calendar(cal) {}
    NCalendar(const Calendar & cal) : Calendar(cal) {}
    
    const std::set<Date> & added() const {
      return impl_->addedHolidays;
    }

    const Impl * impl() const {
      return impl_.get();
    }
  };
}

namespace eepgwde { namespace detail {

  using eepgwde::daemon::Q;
  
  namespace dt = boost::gregorian;
  namespace ba = boost::algorithm;
  namespace fs = boost::filesystem;

  typedef std::pair<fs::path, fs::path> atomic_t;
  typedef std::vector<std::string> compound_t;
  typedef std::map<const std::string, QuantLib::Calendar> cache_t;

  struct nonatom : std::exception {};
  struct notpresent : std::exception {};
  struct uncached : std::exception {};

  class Calendars::Impl {
    friend class Calendars;

    const std::string id_;
    fs::path path_;
    fs::path comp0;
    fs::path comp1;
    fs::path wk;
    boost::regex re_;
    Calendars * owner_;

    QuantLib::Calendar l_;
    QuantLib::Calendar r_;
    std::set<QuantLib::Date> dates_;

    cache_t cache;

    std::set<QuantLib::Weekday> alldays;

  public:

    Impl() throw(std::exception) :
      id_("Calendars::Impl"), path_(".") {
      try {
    update(path_);
      } catch (...) {
      }

      for (eepgwde::daemon::weekday_map_t::iterator
         it = eepgwde::daemon::weekdays.begin();
       it != eepgwde::daemon::weekdays.end();
       ++it) {
    alldays.insert((*it).second);
      }
    }
    
    ~Impl() throw(std::exception) {}

    const std::string & id() {
      return id_;
    }

    void calendars(const QuantLib::Calendar & a,
           const QuantLib::Calendar & b,
           const std::set<QuantLib::Date> & dates) {
      l_ = a;
      r_ = b;
      dates_ = dates;
    }

    QuantLib::Date make(QuantLib::Date *dummy, const std::string & ds)
      throw (std::exception) {
      dt::date d(dt::from_simple_string(ds));

      QuantLib::Month m =
    static_cast<QuantLib::Month>(static_cast<int>(d.month()));

      return QuantLib::Date(/* d-m-y */d.day(),
                m,
                d.year());
    }

    fs::path is_there(const fs::path & p) const throw (std::exception) {
      fs::file_status fs0 = fs::status(p);
      
      if (! fs::exists(fs0))
    throw std::runtime_error(p.leaf() + " does not exist");

      if (! fs::is_directory(fs0))
    throw std::runtime_error(p.leaf() + " is not a directory");

      return p;
    }

    void update(fs::path path0) throw (std::exception) {
      path_ = is_there(path0);
      comp0 = is_there(path_ / eepgwde::daemon::detail::COMP0);
      comp1 = is_there(path_ / eepgwde::daemon::detail::COMP1);
      wk = is_there(path_ / eepgwde::daemon::detail::WK);
    }

    void update1(const std::string & s) {
      boost::regex re(s + "\\." + eepgwde::daemon::detail::suffix + "$");
      re_ = re;
    }

    operator atomic_t() const throw (nonatom) {
      std::set<fs::path> set_;
      std::insert_iterator< std::set<fs::path> > iset_(set_,set_.begin());

      std::set<fs::path> set1_;
      std::insert_iterator< std::set<fs::path> > iset1_(set1_,set1_.begin());

      if (!Q::instance().files(iset_, comp0, re_) ||
      !Q::instance().files(iset1_, wk, re_) ) {
    throw nonatom();
      }

      return atomic_t(*set_.begin(), *set1_.begin());
    }

    operator compound_t() const throw (notpresent) {
      std::set<fs::path> set_;
      std::insert_iterator< std::set<fs::path> > iset_(set_,set_.begin());

      if (!Q::instance().files(iset_, comp1, re_)) {
    throw notpresent();
      }

      return Q::instance().readlines(*set_.begin());
    }

    QuantLib::Calendar & cache_copy(const std::string & name_,
                    QuantLib::Calendar & cal) {
      cache[name_] = cal;
      return cache[name_];
    }
    
    QuantLib::Calendar & cache_copy(const std::string & name_)
      throw (uncached) {
      cache_t::iterator it;
      if (!cache.empty() &&
      (it = cache.find(name_)) != cache.end()) {
#ifndef NDEBUG
    QL_TRACE("cache_copy: found: " + name_);
#endif
    return (*it).second;
      }

      throw uncached();
    }

    QuantLib::Calendar make(QuantLib::Calendar const * dummy,
                const atomic_t & atom,
                const std::string & n = "") 
      throw (std::exception) {

      update(path_);    

      compound_t dates_ = Q::instance().readlines(atom.first);
      compound_t weekdays_ = Q::instance().readlines(atom.second);

#ifndef NDEBUG
      QL_TRACE("Building calendar" +
           atom.first.string() + ", " +
           atom.second.string());

      copy(weekdays_.begin(), weekdays_.end(),
       std::ostream_iterator<std::string>(std::cerr, ","));
      std::cerr << std::endl;
#endif

      std::set<QuantLib::Weekday> weekdays1;
      BOOST_FOREACH(std::string s, weekdays_) {
    eepgwde::daemon::weekday_map_t::iterator it =
      eepgwde::daemon::weekdays.find(s);
    weekdays1.insert((*it).second);
      }

      std::set<QuantLib::Weekday> weekenddays;
      std::insert_iterator<std::set<QuantLib::Weekday> >
    ii(weekenddays, weekenddays.begin());

      std::set_difference(alldays.begin(), alldays.end(),
              weekdays1.begin(), weekdays1.end(),
              ii);

#ifndef NDEBUG
      BOOST_FOREACH(QuantLib::Weekday w, weekenddays) {
    std::cerr << QuantLib::io::long_weekday(w) << std::endl;
      }
#endif

      QuantLib::BespokeCalendar result(n);
      BOOST_FOREACH(QuantLib::Weekday w, weekenddays) {
    result.addWeekend(w);
      }

      BOOST_FOREACH(std::string s, dates_) {
    QuantLib::Date hdt;
    hdt = make(&hdt, s);
    result.addHoliday(hdt);
      }

      return result;
    }

    QuantLib::Calendar make(QuantLib::Calendar const * dummy,
                const compound_t & compound)
      throw (std::exception) {

      update(path_);    

      std::vector<QuantLib::Calendar> calendars;

      BOOST_FOREACH(std::string s, compound) {
    calendars.push_back(Q::instance().make(dummy, s));
      }

      QuantLib::Calendar result;
      BOOST_FOREACH(QuantLib::Calendar s, calendars) {
    if (result.empty()) result = s;
    else {
      QuantLib::JointCalendar join(result, s);
      result = join;
    }
      }

      return result;
    }

    Impl(Impl const &);     // and disabled by link error
    Impl & operator=(Impl const &); // and disabled by link error

  };

  Calendars::Calendars() throw(std::exception) : impl(new Impl) {
    impl->owner_ = this;
  }

  Calendars::~Calendars() throw(std::exception) {}

  QuantLib::Calendar
  Calendars::make(QuantLib::Calendar const * dummy,
          const fs::path & name_)
    throw (std::exception) {
    std::string n = name_.leaf();
    ba::replace_last(n, std::string(".") + eepgwde::daemon::detail::suffix, "");
    return make(dummy, n);
  }
  
  QuantLib::Calendar
  Calendars::make(QuantLib::Calendar const * dummy,
          const std::string & name_)
    throw (std::exception) {
    impl->update(impl->path_);

    try {
      return impl->cache_copy(name_);
    } catch (uncached) {}

    impl->update1(name_);

    atomic_t atom;
    try {
      atom = *(impl.get()); 
      QuantLib::Calendar c = impl->make(dummy, atom, name_);
      impl->cache_copy(name_, c);
      return Q::instance().make(dummy, name_);
    } catch (nonatom e) {
      ;
    }

    // This is now a non-atomic calendar

    compound_t compound;
    try {
      compound = *(impl.get()); 
      QuantLib::Calendar c = impl->make(dummy, compound);
      impl->cache_copy(name_, c);
      return Q::instance().make(dummy, name_);
    } catch (notpresent e) {
      std::string m("unknown calendar " +
            name_ +
            " within " +
            path().string());
      QL_TRACE(m);
      throw std::runtime_error(m);
    }

    return *dummy;
  }

  std::pair<QuantLib::Date, QuantLib::Date>
  Calendars::added(QuantLib::Calendar const & c)
    throw(std::exception) {
    QuantLib::Calendar ncal0 = static_cast<QuantLib::Calendar>(c);
    QuantLib::NCalendar ncal(ncal0);

    const std::set<QuantLib::Date> added = ncal.added();
    if (!added.size()) {
      throw runtime_error(c.name() + ": has no added holidays");
    }
      
    std::pair<QuantLib::Date, QuantLib::Date> result =
      std::make_pair(*added.begin(), *added.rbegin());

    return result;
  }

  const std::string & Calendars::id() const {
    return impl->id();
  }

  fs::path Calendars::path() const {
    return impl->path_;
  }

  fs::path Calendars::path(const fs::path & path_)
    throw(std::exception) {
    impl->update(path_);
    return path();
  }

  std::set<QuantLib::Date> Calendars::dates() {
    return impl->dates_;
  }

  std::set<QuantLib::Date> 
  Calendars::set_difference(const QuantLib::Calendar & a,
                const QuantLib::Calendar & b,
                const QuantLib::Date & from_,
                const QuantLib::Date & to_)
    throw(std::exception) {
    
    std::vector<QuantLib::Date> holidays0, holidays1;
    holidays0 = QuantLib::Calendar::holidayList(a, from_, to_, 1);
    holidays1 = QuantLib::Calendar::holidayList(b, from_, to_, 1);

    std::set<QuantLib::Date> diffs;
    std::insert_iterator<std::set<QuantLib::Date> >
      idiffs(diffs, diffs.begin());
  
    std::set_difference(holidays0.begin(), holidays0.end(),
            holidays1.begin(), holidays1.end(),
            idiffs);
    
    impl->calendars(a, b, diffs);

    return diffs;
  }

  const std::map<const std::string, QuantLib::Calendar> &
  Calendars::mismatches() const {
    return eepgwde::daemon::mismatches;
  }

  const std::map<const std::string, QuantLib::Calendar> &
  Calendars::mismatches(const std::map<const std::string, QuantLib::Calendar> &m) {
    eepgwde::daemon::mismatches = m;
    return mismatches();
  }

  const std::map<const std::string, QuantLib::Calendar> & Calendars::fix()
    throw (std::exception) {
    return fix(path());
  }

  const std::map<const std::string, QuantLib::Calendar> &
  Calendars::fix(const fs::path & path_) throw(std::exception) {
    path(path_);
    std::map<const std::string, QuantLib::Calendar> mismatches0 =
      this->mismatches() ;

    for (std::map<const std::string, QuantLib::Calendar>::iterator
       it = mismatches0.begin(); it != mismatches0.end(); ++it) {
      QuantLib::Calendar cal = make(&cal, it->first);
      QuantLib::Calendar & c = it->second;
      if (eepgwde::operator==(cal, c)) continue;
      
      std::set<QuantLib::Date> dates0 = this->dates();
      BOOST_FOREACH(QuantLib::Date d0, dates0) {
    if (cal.isHoliday(d0) && !c.isHoliday(d0))
      c.addHoliday(d0);
    else if (!cal.isHoliday(d0) && c.isHoliday(d0))
      c.removeHoliday(d0);
      }
    }

    return this->mismatches();
  }
}}

namespace eepgwde {
  
  bool operator!= (QuantLib::Calendar const & a,
           QuantLib::Calendar const & b) 
    throw(std::invalid_argument) {
    return !eepgwde::operator==(a, b);
  }

  bool operator== (QuantLib::Calendar const & a,
           QuantLib::Calendar const & b) 
    throw(std::invalid_argument) {
    if (QuantLib::operator==(a, b) ) return true;
    if (&a == &b) return true;

    QuantLib::NCalendar an(a);
    QuantLib::NCalendar bn(b);

    if (an.impl() == bn.impl()) {
      QL_TRACE("eepgwde::operator==(Calendar, Calendar) implementation match");
      return true;
    }

    if (a.empty() && !b.empty()) return false;
    if (b.empty() && !a.empty()) return false;

    // No more useful comparisons. These are based on comparing a BespokeCalendar
    // in its added holiday range to another calendar.

    // Compare dissimilar objects by comparing lists.

    const QuantLib::Calendar * src = &a;
    const QuantLib::Calendar * target = &b;
    std::pair<QuantLib::Date, QuantLib::Date> src_range;

    #ifndef NDEBUG
    {
      try {
    src_range = eepgwde::daemon::Q::instance().added(*src);
    QuantLib::Date & from_ = src_range.first;
    QuantLib::Date & to_ = src_range.second;
    QL_TRACE("QuantLib::Calendar::" <<
         "(" << src->name() << ") "
         << QuantLib::io::iso_date(from_) << " "
         << QuantLib::io::iso_date(to_) << " ");
      } catch (std::exception & e) {
    QL_TRACE("src failed: " + src->name());
      }
    }

    {
      try {
    src_range = eepgwde::daemon::Q::instance().added(*target);
    QuantLib::Date & from_ = src_range.first;
    QuantLib::Date & to_ = src_range.second;
    QL_TRACE("QuantLib::Calendar::" <<
         "(" << target->name() << ") "
         << QuantLib::io::iso_date(from_) << " "
         << QuantLib::io::iso_date(to_) << " ");
      } catch (std::exception & e) {
    QL_TRACE("target failed: " + target->name());
      }
    }
    #endif

    try {
      src = &a;
      target = &b;
      src_range = eepgwde::daemon::Q::instance().added(*src);
    } catch (std::exception & e) {
      try {
    src = &b;
    target = &a;
    src_range = eepgwde::daemon::Q::instance().added(*src);
      } catch (std::exception & e) { 
    /* 
       std::string m =
       std::string("neither " + a.name() + " nor " + b.name() + " is comparable");
       throw std::invalid_argument(m);
    */
    QL_TRACE("eepgwde::operator==(Calendar, Calendar) mismatch");
    return false;
      }
    }

    QuantLib::Date & from_ = src_range.first;
    QuantLib::Date & to_ = src_range.second;

    if (! (to_ > from_) ) return false;

    std::set<QuantLib::Date> diffs;
    diffs = eepgwde::daemon::Q::instance().set_difference(*src, *target, from_, to_);

    #ifndef NDEBUG
    QL_TRACE("QuantLib::Calendar::" <<
         "(" << src->name() << ", " << target->name() << ") "
         << QuantLib::io::iso_date(from_) << " "
         << QuantLib::io::iso_date(to_) << " "
         << "differences: " << diffs.size() );

    QL_TRACE("eepgwde::operator==(Calendar, Calendar) added() diffs: " << src->name() << " " << target->name() << " " << diffs.size() );
    #endif

    return diffs.size() == 0;
  }

}

---