colouringcode-passenger 0.1

data/ext/boost/date_time/date_generators.hpp

@@ -0,0 +1,509 @@
+#ifndef DATE_TIME_DATE_GENERATORS_HPP__
+#define DATE_TIME_DATE_GENERATORS_HPP__
+
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst 
+ * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ */
+
+/*! @file date_generators.hpp
+  Definition and implementation of date algorithm templates
+*/
+#include <stdexcept>
+#include <sstream>
+#include "boost/date_time/date.hpp"
+#include "boost/date_time/compiler_config.hpp"
+
+namespace boost {
+namespace date_time {
+
+  //! Base class for all generators that take a year and produce a date.
+  /*! This class is a base class for polymorphic function objects that take
+    a year and produce a concrete date.
+    @param date_type The type representing a date.  This type must
+    export a calender_type which defines a year_type.
+  */
+  template<class date_type>
+  class year_based_generator
+  {
+  public:
+    typedef typename date_type::calendar_type calendar_type;
+    typedef typename calendar_type::year_type        year_type;
+    year_based_generator() {};
+    virtual ~year_based_generator() {};
+    virtual date_type get_date(year_type y) const = 0;
+    //! Returns a string for use in a POSIX time_zone string
+    virtual std::string to_string() const =0;
+  };
+  
+  //! Generates a date by applying the year to the given month and day.
+  /*!
+    Example usage: 
+    @code
+    partial_date pd(1, Jan);
+    partial_date pd2(70);
+    date d = pd.get_date(2002); //2002-Jan-01
+    date d2 = pd2.get_date(2002); //2002-Mar-10
+    @endcode
+    \ingroup date_alg
+  */
+  template<class date_type>
+ class partial_date : public year_based_generator<date_type>
+ {
+ public:
+   typedef typename date_type::calendar_type calendar_type;
+   typedef typename calendar_type::day_type         day_type;
+   typedef typename calendar_type::month_type       month_type;
+   typedef typename calendar_type::year_type        year_type;
+   typedef typename date_type::duration_type        duration_type;
+   typedef typename duration_type::duration_rep     duration_rep;
+   partial_date(day_type d, month_type m) :
+     day_(d),
+     month_(m)
+   {}
+   //! Partial date created from number of days into year. Range 1-366
+   /*! Allowable values range from 1 to 366. 1=Jan1, 366=Dec31. If argument
+    * exceeds range, partial_date will be created with closest in-range value.
+    * 60 will always be Feb29, if get_date() is called with a non-leap year
+    * an exception will be thrown */
+   partial_date(duration_rep days) :
+     day_(1), // default values
+     month_(1)
+   {
+     date_type d1(2000,1,1);
+     if(days > 1) {
+       if(days > 366) // prevents wrapping
+       {
+         days = 366;
+       }
+       days = days - 1;
+       duration_type dd(days);
+       d1 = d1 + dd;
+     }
+     day_ = d1.day();
+     month_ = d1.month();
+   }
+   //! Return a concrete date when provided with a year specific year.
+   /*! Will throw an 'invalid_argument' exception if a partial_date object,
+    * instantiated with Feb-29, has get_date called with a non-leap year.
+    * Example:
+    * @code
+    * partial_date pd(29, Feb);
+    * pd.get_date(2003); // throws invalid_argument exception
+    * pg.get_date(2000); // returns 2000-2-29
+    * @endcode
+         */
+   date_type get_date(year_type y) const
+   {
+     if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
+       std::stringstream ss("");
+       ss << "No Feb 29th in given year of " << y << ".";
+       throw std::invalid_argument(ss.str());
+       //return date_type(1,1,1); // should never reach
+     } else {
+       return date_type(y, month_, day_);
+     }
+   }
+   date_type operator()(year_type y) const
+   {
+     return get_date(y);
+     //return date_type(y, month_, day_);
+   }
+   bool operator==(const partial_date& rhs) const
+   {
+     return (month_ == rhs.month_) && (day_ == rhs.day_);
+   }
+   bool operator<(const partial_date& rhs) const
+   {
+     if (month_ < rhs.month_) return true;
+     if (month_ > rhs.month_) return false;
+     //months are equal
+     return (day_ < rhs.day_);
+   }
+   
+   // added for streaming purposes
+   month_type month() const 
+   {
+     return month_;
+   }
+   day_type day() const
+   {
+     return day_;
+   }
+
+   //! Returns string suitable for use in POSIX time zone string
+   /*! Returns string formatted with up to 3 digits: 
+    * Jan-01 == "0" 
+    * Feb-29 == "58"
+    * Dec-31 == "365" */
+   virtual std::string to_string() const
+   {
+     std::stringstream ss;
+     date_type d(2004, month_, day_);
+     unsigned short c = d.day_of_year();     
+     c--; // numbered 0-365 while day_of_year is 1 based...
+     ss << c;
+     return ss.str();
+   }
+ private:
+   day_type day_;
+   month_type month_;
+ };
+
+
+  //! Useful generator functor for finding holidays
+  /*! Based on the idea in Cal. Calc. for finding holidays that are
+   *  the 'first Monday of September'. When instantiated with
+   *  'fifth' kday of month, the result will be the last kday of month
+   *  which can be the fourth or fifth depending on the structure of 
+   *  the month.
+   *
+   *  The algorithm here basically guesses for the first
+   *  day of the month.  Then finds the first day of the correct
+   *  type.  That is, if the first of the month is a Tuesday
+   *  and it needs Wenesday then we simply increment by a day
+   *  and then we can add the length of a week until we get
+   *  to the 'nth kday'.  There are probably more efficient 
+   *  algorithms based on using a mod 7, but this one works 
+   *  reasonably well for basic applications.
+   *  \ingroup date_alg
+   */
+  template<class date_type>
+  class nth_kday_of_month : public year_based_generator<date_type>
+  {
+  public:
+    typedef typename date_type::calendar_type calendar_type;
+    typedef typename calendar_type::day_of_week_type  day_of_week_type;
+    typedef typename calendar_type::month_type        month_type;
+    typedef typename calendar_type::year_type         year_type;
+    typedef typename date_type::duration_type        duration_type;
+    enum week_num {first=1, second, third, fourth, fifth};
+    nth_kday_of_month(week_num week_no,
+                      day_of_week_type dow,
+                      month_type m) :
+      month_(m),
+      wn_(week_no),
+      dow_(dow)
+    {}
+    //! Return a concrete date when provided with a year specific year.
+    date_type get_date(year_type y) const
+    {
+      date_type d(y, month_, 1); //first day of month
+      duration_type one_day(1);
+      duration_type one_week(7);
+      while (dow_ != d.day_of_week()) {
+        d = d + one_day;
+      }
+      int week = 1;
+      while (week < wn_) {
+        d = d + one_week;
+        week++;
+      }
+      // remove wrapping to next month behavior
+      if(d.month() != month_) {
+        d = d - one_week;
+      }
+      return d;
+    }
+    // added for streaming
+    month_type month() const
+    {
+      return month_;
+    }
+    week_num nth_week() const
+    {
+      return wn_;
+    }
+    day_of_week_type day_of_week() const
+    {
+      return dow_;
+    }
+    const char* nth_week_as_str() const
+    {
+      return nth_as_str(wn_);
+    }
+    //! Returns string suitable for use in POSIX time zone string
+    /*! Returns a string formatted as "M4.3.0" ==> 3rd Sunday in April. */
+    virtual std::string to_string() const
+    {
+     std::stringstream ss;
+     ss << 'M' 
+       << static_cast<int>(month_) << '.'
+       << static_cast<int>(wn_) << '.'
+       << static_cast<int>(dow_);
+     return ss.str();
+    }
+  private:
+    month_type month_;
+    week_num wn_;
+    day_of_week_type dow_;
+  };
+  
+  //! Returns nth arg as string. 1 -> "first", 2 -> "second", max is 5.
+  BOOST_DATE_TIME_DECL const char* nth_as_str(int n);
+
+  //! Useful generator functor for finding holidays and daylight savings
+  /*! Similar to nth_kday_of_month, but requires less paramters
+   *  \ingroup date_alg
+   */
+  template<class date_type>
+  class first_kday_of_month : public year_based_generator<date_type>
+  {
+  public:
+    typedef typename date_type::calendar_type calendar_type;
+    typedef typename calendar_type::day_of_week_type  day_of_week_type;
+    typedef typename calendar_type::month_type        month_type;
+    typedef typename calendar_type::year_type         year_type;
+    typedef typename date_type::duration_type        duration_type;
+    //!Specify the first 'Sunday' in 'April' spec
+    /*!@param dow The day of week, eg: Sunday, Monday, etc
+     * @param m The month of the year, eg: Jan, Feb, Mar, etc
+     */
+    first_kday_of_month(day_of_week_type dow, month_type m) :
+      month_(m),
+      dow_(dow)
+    {}
+    //! Return a concrete date when provided with a year specific year.
+    date_type get_date(year_type year) const
+    {
+      date_type d(year, month_,1);
+      duration_type one_day(1);
+      while (dow_ != d.day_of_week()) {
+        d = d + one_day;
+      }
+      return d;
+        }
+    // added for streaming
+    month_type month() const
+    {
+      return month_;
+    }
+    day_of_week_type day_of_week() const
+    {
+      return dow_;
+    }
+    //! Returns string suitable for use in POSIX time zone string
+    /*! Returns a string formatted as "M4.1.0" ==> 1st Sunday in April. */
+    virtual std::string to_string() const
+    {
+     std::stringstream ss;
+     ss << 'M' 
+       << static_cast<int>(month_) << '.'
+       << 1 << '.'
+       << static_cast<int>(dow_);
+     return ss.str();
+    }
+  private:
+    month_type month_;
+    day_of_week_type dow_;
+  };
+  
+  
+  
+  //! Calculate something like Last Sunday of January
+  /*! Useful generator functor for finding holidays and daylight savings
+   *  Get the last day of the month and then calculate the difference
+   *  to the last previous day.
+   *  @param date_type A date class that exports day_of_week, month_type, etc.
+   *  \ingroup date_alg
+   */
+  template<class date_type>
+  class last_kday_of_month : public year_based_generator<date_type>
+  {
+  public:
+    typedef typename date_type::calendar_type calendar_type;
+    typedef typename calendar_type::day_of_week_type  day_of_week_type;
+    typedef typename calendar_type::month_type        month_type;
+    typedef typename calendar_type::year_type         year_type;
+    typedef typename date_type::duration_type        duration_type;
+    //!Specify the date spec like last 'Sunday' in 'April' spec
+    /*!@param dow The day of week, eg: Sunday, Monday, etc
+     * @param m The month of the year, eg: Jan, Feb, Mar, etc
+     */
+    last_kday_of_month(day_of_week_type dow, month_type m) :
+      month_(m),
+      dow_(dow)
+    {}
+    //! Return a concrete date when provided with a year specific year.
+    date_type get_date(year_type year) const
+    {
+      date_type d(year, month_, calendar_type::end_of_month_day(year,month_));
+      duration_type one_day(1);
+      while (dow_ != d.day_of_week()) {
+        d = d - one_day;
+      }
+      return d;
+    }
+    // added for streaming
+    month_type month() const
+    {
+      return month_;
+    }
+    day_of_week_type day_of_week() const
+    {
+      return dow_;
+    }
+    //! Returns string suitable for use in POSIX time zone string
+    /*! Returns a string formatted as "M4.5.0" ==> last Sunday in April. */
+    virtual std::string to_string() const
+    {
+      std::stringstream ss;
+      ss << 'M' 
+         << static_cast<int>(month_) << '.'
+         << 5 << '.'
+         << static_cast<int>(dow_);
+      return ss.str();
+    }
+  private:
+    month_type month_;
+    day_of_week_type dow_;
+   };
+  
+  
+  //! Calculate something like "First Sunday after Jan 1,2002
+  /*! Date generator that takes a date and finds kday after
+   *@code
+     typedef boost::date_time::first_kday_after<date> firstkdayafter;
+     firstkdayafter fkaf(Monday);
+     fkaf.get_date(date(2002,Feb,1));
+   @endcode
+   *  \ingroup date_alg
+   */
+  template<class date_type>
+  class first_kday_after
+  {
+  public:
+    typedef typename date_type::calendar_type calendar_type;
+    typedef typename calendar_type::day_of_week_type day_of_week_type;
+    typedef typename date_type::duration_type        duration_type;
+    first_kday_after(day_of_week_type dow) :
+      dow_(dow)
+    {}
+    //! Return next kday given.
+    date_type get_date(date_type start_day) const
+    {
+      duration_type one_day(1);
+      date_type d = start_day + one_day;
+      while (dow_ != d.day_of_week()) {
+        d = d + one_day;
+      }
+      return d;
+    }
+    // added for streaming
+    day_of_week_type day_of_week() const
+    {
+      return dow_;
+    }
+  private:
+    day_of_week_type dow_;
+  };
+  
+  //! Calculate something like "First Sunday before Jan 1,2002
+  /*! Date generator that takes a date and finds kday after
+   *@code
+     typedef boost::date_time::first_kday_before<date> firstkdaybefore;
+     firstkdaybefore fkbf(Monday);
+     fkbf.get_date(date(2002,Feb,1));
+   @endcode
+   *  \ingroup date_alg
+   */
+  template<class date_type>
+  class first_kday_before
+  {
+  public:
+    typedef typename date_type::calendar_type calendar_type;
+    typedef typename calendar_type::day_of_week_type day_of_week_type;
+    typedef typename date_type::duration_type        duration_type;
+    first_kday_before(day_of_week_type dow) :
+      dow_(dow)
+    {}
+    //! Return next kday given.
+    date_type get_date(date_type start_day) const
+    {
+      duration_type one_day(1);
+      date_type d = start_day - one_day;
+      while (dow_ != d.day_of_week()) {
+        d = d - one_day;
+      }
+      return d;
+    }
+    // added for streaming
+    day_of_week_type day_of_week() const
+    {
+      return dow_;
+    }
+  private:
+    day_of_week_type dow_;
+  };
+  
+  //! Calculates the number of days until the next weekday
+  /*! Calculates the number of days until the next weekday.
+   * If the date given falls on a Sunday and the given weekday 
+   * is Tuesday the result will be 2 days */
+  template<typename date_type, class weekday_type>
+  inline
+  typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
+  {
+    typedef typename date_type::duration_type duration_type;
+    duration_type wks(0);
+    duration_type dd(wd.as_number() - d.day_of_week().as_number());
+    if(dd.is_negative()){
+      wks = duration_type(7);
+    }
+    return dd + wks;
+  }
+
+  //! Calculates the number of days since the previous weekday
+  /*! Calculates the number of days since the previous weekday
+   * If the date given falls on a Sunday and the given weekday 
+   * is Tuesday the result will be 5 days. The answer will be a positive 
+   * number because Tuesday is 5 days before Sunday, not -5 days before. */
+  template<typename date_type, class weekday_type>
+  inline
+  typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
+  {
+    typedef typename date_type::duration_type duration_type;
+    duration_type wks(0);
+    duration_type dd(wd.as_number() - d.day_of_week().as_number());
+    if(dd.days() > 0){
+      wks = duration_type(7);
+    }
+    // we want a number of days, not an offset. The value returned must
+    // be zero or larger.
+    return (-dd + wks);
+  }
+
+  //! Generates a date object representing the date of the following weekday from the given date
+  /*! Generates a date object representing the date of the following 
+   * weekday from the given date. If the date given is 2004-May-9 
+   * (a Sunday) and the given weekday is Tuesday then the resulting date 
+   * will be 2004-May-11. */
+  template<class date_type, class weekday_type>
+  inline
+  date_type next_weekday(const date_type& d, const weekday_type& wd)
+  {
+    return d + days_until_weekday(d, wd);
+  }
+
+  //! Generates a date object representing the date of the previous weekday from the given date
+  /*! Generates a date object representing the date of the previous 
+   * weekday from the given date. If the date given is 2004-May-9 
+   * (a Sunday) and the given weekday is Tuesday then the resulting date 
+   * will be 2004-May-4. */
+  template<class date_type, class weekday_type>
+  inline
+  date_type previous_weekday(const date_type& d, const weekday_type& wd)
+  {
+    return d - days_before_weekday(d, wd);
+  }
+
+} } //namespace date_time
+
+
+
+
+#endif
+

data/ext/boost/date_time/date_iterator.hpp

@@ -0,0 +1,101 @@
+#ifndef DATE_ITERATOR_HPP___
+#define DATE_ITERATOR_HPP___
+
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ */
+
+#include <iterator>
+
+namespace boost {
+namespace date_time {
+  //! An iterator over dates with varying resolution (day, week, month, year, etc)
+  enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
+
+  //! Base date iterator type
+  /*! This class provides the skeleton for the creation of iterators.
+   *  New and interesting interators can be created by plugging in a new
+   *  function that derives the next value from the current state.
+   *  generation of various types of -based information.
+   *
+   *  <b>Template Parameters</b>
+   *
+   *  <b>date_type</b>
+   *
+   *  The date_type is a concrete date_type. The date_type must
+   *  define a duration_type and a calendar_type.
+   */
+  template<class date_type>
+  class date_itr_base {
+  // works, but benefit unclear at the moment
+  //   class date_itr_base : public std::iterator<std::input_iterator_tag, 
+  //                                             date_type, void, void, void>{
+  public:
+    typedef typename date_type::duration_type duration_type;
+    typedef date_type value_type;
+    typedef std::input_iterator_tag iterator_category;
+
+    date_itr_base(date_type d) : current_(d) {}
+    virtual ~date_itr_base() {};
+    date_itr_base& operator++() 
+    {
+      current_ = current_ + get_offset(current_);
+      return *this;
+    }
+    date_itr_base& operator--() 
+    {
+      current_ = current_ + get_neg_offset(current_);
+      return *this;
+    }
+    virtual duration_type get_offset(const date_type& current) const=0;
+    virtual duration_type get_neg_offset(const date_type& current) const=0;
+    date_type operator*() {return current_;};
+    date_type* operator->() {return &current_;};
+    bool operator<  (const date_type& d) {return current_ < d;}
+    bool operator<= (const date_type& d) {return current_ <= d;}
+    bool operator>  (const date_type& d) {return current_ > d;}
+    bool operator>= (const date_type& d) {return current_ >= d;}
+    bool operator== (const date_type& d) {return current_ == d;}
+    bool operator!= (const date_type& d) {return current_ != d;}    
+  private:
+    date_type current_;
+  };
+  
+  //! Overrides the base date iterator providing hook for functors
+  /*
+   *  <b>offset_functor</b>
+   *
+   *  The offset functor must define a get_offset function that takes the
+   *  current point in time and calculates and offset.
+   *
+   */
+  template<class offset_functor, class date_type>
+  class date_itr : public date_itr_base<date_type> {
+  public:
+    typedef typename date_type::duration_type duration_type;
+    date_itr(date_type d, int factor=1) : 
+      date_itr_base<date_type>(d), 
+      of_(factor) 
+    {}
+  private:
+    virtual duration_type get_offset(const date_type& current) const
+    {
+      return of_.get_offset(current);
+    }
+    virtual duration_type get_neg_offset(const date_type& current) const
+    {
+      return of_.get_neg_offset(current);
+    }
+    offset_functor of_;
+  };
+  
+
+  
+} } //namespace date_time
+
+
+#endif