rockdog-passenger 0.0.1

data/ext/boost/date_time/adjust_functors.hpp

@@ -0,0 +1,178 @@
+#ifndef _DATE_TIME_ADJUST_FUNCTORS_HPP___
+#define _DATE_TIME_ADJUST_FUNCTORS_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 "boost/date_time/date.hpp"
+#include "boost/date_time/wrapping_int.hpp"
+
+namespace boost {
+namespace date_time {
+  
+
+  //! Functor to iterate a fixed number of days
+  template<class date_type>
+  class day_functor 
+  {
+  public:
+    typedef typename date_type::duration_type duration_type;
+    day_functor(int f) : f_(f) {}
+    duration_type get_offset(const date_type& d) const 
+    {
+      // why is 'd' a parameter???
+      // fix compiler warnings
+      d.year();
+      return duration_type(f_);
+    }
+    duration_type get_neg_offset(const date_type& d) const 
+    {
+      // fix compiler warnings
+      d.year();
+      return duration_type(-f_);
+    }
+  private:
+    int f_;
+  };
+
+
+  //! Provides calculation to find next nth month given a date
+  /*! This adjustment function provides the logic for 'month-based'
+   *  advancement on a ymd based calendar.  The policy it uses 
+   *  to handle the non existant end of month days is to back
+   *  up to the last day of the month.  Also, if the starting
+   *  date is the last day of a month, this functor will attempt
+   *  to adjust to the end of the month.
+
+   */
+  template<class date_type>
+  class month_functor 
+  {
+  public:
+    typedef typename date_type::duration_type duration_type;
+    typedef typename date_type::calendar_type cal_type;
+    typedef typename cal_type::ymd_type ymd_type;
+    typedef typename cal_type::day_type day_type;
+
+    month_functor(int f) : f_(f), origDayOfMonth_(0) {}
+    duration_type get_offset(const date_type& d) const 
+    {
+      ymd_type ymd(d.year_month_day());
+      if (origDayOfMonth_ == 0) {
+        origDayOfMonth_ = ymd.day;
+        day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
+        if (endOfMonthDay == ymd.day) {
+          origDayOfMonth_ = -1; //force the value to the end of month
+        }
+      }
+      typedef date_time::wrapping_int2<short,1,12> wrap_int2;
+      typedef typename wrap_int2::int_type int_type;
+      wrap_int2 wi(ymd.month);
+      //calc the year wrap around, add() returns 0 or 1 if wrapped
+      int_type year = wi.add(static_cast<int_type>(f_)); 
+      year = static_cast<int_type>(year + ymd.year); //calculate resulting year
+//       std::cout << "trace wi: " << wi.as_int() << std::endl;
+//       std::cout << "trace year: " << year << std::endl;
+      //find the last day for the new month
+      day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));
+      //original was the end of month -- force to last day of month
+      if (origDayOfMonth_ == -1) {
+        return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
+      }
+      day_type dayOfMonth = origDayOfMonth_;
+      if (dayOfMonth > resultingEndOfMonthDay) {
+        dayOfMonth = resultingEndOfMonthDay;
+      }
+      return date_type(year, wi.as_int(), dayOfMonth) - d;
+    }
+    //! Returns a negative duration_type
+    duration_type get_neg_offset(const date_type& d) const 
+    {
+      ymd_type ymd(d.year_month_day());
+      if (origDayOfMonth_ == 0) {
+        origDayOfMonth_ = ymd.day;
+        day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
+        if (endOfMonthDay == ymd.day) {
+          origDayOfMonth_ = -1; //force the value to the end of month
+        }
+      }
+      typedef date_time::wrapping_int2<short,1,12> wrap_int2;
+      typedef typename wrap_int2::int_type int_type;
+      wrap_int2 wi(ymd.month);
+      //calc the year wrap around, add() returns 0 or 1 if wrapped
+      int_type year = wi.subtract(static_cast<int_type>(f_)); 
+      year = static_cast<int_type>(year + ymd.year); //calculate resulting year
+      //find the last day for the new month
+      day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));
+      //original was the end of month -- force to last day of month
+      if (origDayOfMonth_ == -1) {
+        return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
+      }
+      day_type dayOfMonth = origDayOfMonth_;
+      if (dayOfMonth > resultingEndOfMonthDay) {
+        dayOfMonth = resultingEndOfMonthDay;
+      }
+      return date_type(year, wi.as_int(), dayOfMonth) - d;
+    }
+  private:
+    int f_;
+    mutable short origDayOfMonth_;
+  };
+
+
+  //! Functor to iterate a over weeks
+  template<class date_type>
+  class week_functor 
+  {
+  public:
+    typedef typename date_type::duration_type duration_type;
+    typedef typename date_type::calendar_type calendar_type;
+    week_functor(int f) : f_(f) {}
+    duration_type get_offset(const date_type& d) const 
+    {
+      // why is 'd' a parameter???
+      // fix compiler warnings
+      d.year();
+      return duration_type(f_*calendar_type::days_in_week());
+    }
+    duration_type get_neg_offset(const date_type& d) const 
+    {
+      // fix compiler warnings
+      d.year();
+      return duration_type(-f_*calendar_type::days_in_week());
+    }
+  private:
+    int f_;
+  };
+
+  //! Functor to iterate by a year adjusting for leap years
+  template<class date_type>
+  class year_functor 
+  {
+  public:
+    //typedef typename date_type::year_type year_type;
+    typedef typename date_type::duration_type duration_type;
+    year_functor(int f) : _mf(f * 12) {}
+    duration_type get_offset(const date_type& d) const 
+    {
+      return _mf.get_offset(d);
+    }
+    duration_type get_neg_offset(const date_type& d) const 
+    {
+      return _mf.get_neg_offset(d);
+    }
+  private:
+    month_functor<date_type> _mf;
+  };
+
+  
+} }//namespace date_time
+
+
+#endif
+

data/ext/boost/date_time/c_time.hpp

@@ -0,0 +1,91 @@
+#ifndef DATE_TIME_C_TIME_HPP___
+#define DATE_TIME_C_TIME_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 c_time.hpp
+  Provide workarounds related to the ctime header
+*/
+
+#include "boost/date_time/compiler_config.hpp"
+#include <ctime>
+//Work around libraries that don't put time_t and time in namespace std
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std { using ::time_t; using ::time; using ::localtime;
+                using ::tm;  using ::gmtime; }
+#endif // BOOST_NO_STDC_NAMESPACE
+
+//The following is used to support high precision time clocks
+#ifdef BOOST_HAS_GETTIMEOFDAY
+#include <sys/time.h>
+#endif
+
+#ifdef BOOST_HAS_FTIME
+#include <time.h>
+#endif
+
+namespace boost {
+namespace date_time {
+  //! Provides a uniform interface to some 'ctime' functions
+  /*! Provides a uniform interface to some ctime functions and 
+   * their '_r' counterparts. The '_r' functions require a pointer to a 
+   * user created std::tm struct whereas the regular functions use a 
+   * staticly created struct and return a pointer to that. These wrapper 
+   * functions require the user to create a std::tm struct and send in a 
+   * pointer to it. A pointer to the user created struct will be returned. */
+  struct c_time {
+    public:
+#if defined(BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS)
+      //! requires a pointer to a user created std::tm struct
+      inline
+      static std::tm* localtime(const std::time_t* t, std::tm* result)
+      {
+        // localtime_r() not in namespace std???
+        result = localtime_r(t, result);
+        return result;
+      }
+      //! requires a pointer to a user created std::tm struct
+      inline
+      static std::tm* gmtime(const std::time_t* t, std::tm* result)
+      {
+        // gmtime_r() not in namespace std???
+        result = gmtime_r(t, result);
+        return result;
+      }
+#else // BOOST_HAS_THREADS
+
+#if (defined(_MSC_VER) && (_MSC_VER >= 1400))
+#pragma warning(push) // preserve warning settings
+#pragma warning(disable : 4996) // disable depricated localtime/gmtime warning on vc8
+#endif // _MSC_VER >= 1400
+      //! requires a pointer to a user created std::tm struct
+      inline
+      static std::tm* localtime(const std::time_t* t, std::tm* result)
+      {
+        result = std::localtime(t);
+        return result;
+      }
+      //! requires a pointer to a user created std::tm struct
+      inline
+      static std::tm* gmtime(const std::time_t* t, std::tm* result)
+      {
+        result = std::gmtime(t);
+        return result;
+      }
+#if (defined(_MSC_VER) && (_MSC_VER >= 1400))
+#pragma warning(pop) // restore warnings to previous state
+#endif // _MSC_VER >= 1400
+
+#endif // BOOST_HAS_THREADS
+  };
+}} // namespaces
+                
+#endif // DATE_TIME_C_TIME_HPP___

data/ext/boost/date_time/compiler_config.hpp

@@ -0,0 +1,149 @@
+#ifndef DATE_TIME_COMPILER_CONFIG_HPP___
+#define DATE_TIME_COMPILER_CONFIG_HPP___
+
+/* Copyright (c) 2002-2004 CrystalClear Software, Inc.
+ * 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 "boost/detail/workaround.hpp"
+
+// With boost release 1.33, date_time will be using a different,
+// more flexible, IO system. This new system is not compatible with
+// old compilers. The original date_time IO system remains for those
+// compilers. They must define this macro to use the legacy IO.
+//     (defined(__BORLANDC__) && (__BORLANDC__ <= 0x0581) ) )   &&
+ #if(  BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) ) \
+    || BOOST_WORKAROUND( __GNUC__, < 3)                         \
+    || (BOOST_WORKAROUND( _MSC_VER, <= 1300) )                  \
+    )                                                           \
+    && !defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
+# define USE_DATE_TIME_PRE_1_33_FACET_IO
+#endif
+
+
+// This file performs some local compiler configurations
+
+#include "boost/date_time/locale_config.hpp" //set up locale configurations
+
+//Set up a configuration parameter for platforms that have 
+//GetTimeOfDay
+#if defined(BOOST_HAS_GETTIMEOFDAY) || defined(BOOST_HAS_FTIME)
+#define BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
+#endif
+
+// To Force no default constructors for date & ptime, un-comment following
+//#define DATE_TIME_NO_DEFAULT_CONSTRUCTOR
+
+// Include extensions to date_duration - comment out to remove this feature
+#define BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
+// these extensions are known to cause problems with gcc295
+#if defined(__GNUC__) && (__GNUC__ < 3)
+#undef BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
+#endif
+
+#if (defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) || BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT(0x581) ) )
+#define BOOST_DATE_TIME_NO_MEMBER_INIT
+#endif
+
+// include these types before we try to re-define them
+#include "boost/cstdint.hpp"
+
+//Define INT64_C for compilers that don't have it
+#if (!defined(INT64_C))
+#define INT64_C(value)  int64_t(value)
+#endif
+
+
+/* Workaround for Borland iterator error. Error was "Cannot convert 'istream *' to 'wistream *' in function istream_iterator<>::istream_iterator() */
+#if defined(__BORLANDC__) && defined(BOOST_BCB_WITH_RW_LIB)
+#define BOOST_DATE_TIME_NO_WISTREAM_ITERATOR
+#endif
+
+
+// Borland v5.64 does not have the following in std namespace; v5.5.1 does
+#if defined(__BORLANDC__) && defined(BOOST_BCB_WITH_STLPORT)
+#include <locale>
+namespace std {
+  using stlport::tolower;
+  using stlport::ctype;
+  using stlport::use_facet;
+}
+#endif
+
+// workaround for errors associated with output for date classes 
+// modifications and input streaming for time classes. 
+// Compilers affected are:
+// gcc295, msvc (neither with STLPort), any borland
+// 
+#if (((defined(__GNUC__) && (__GNUC__ < 3)) || \
+      (defined(_MSC_VER) && (_MSC_VER < 1300)) ) && \
+      !defined(_STLP_OWN_IOSTREAMS) ) || \
+      BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
+#define BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
+#endif
+
+/* The following handles the definition of the necessary macros
+ * for dll building on Win32 platforms.
+ * 
+ * For code that will be placed in the date_time .dll, 
+ * it must be properly prefixed with BOOST_DATE_TIME_DECL.
+ * The corresponding .cpp file must have BOOST_DATE_TIME_SOURCES
+ * defined before including its header. For examples see:
+ * greg_month.hpp & greg_month.cpp
+ * 
+ */
+
+#ifdef BOOST_HAS_DECLSPEC // defined in config system
+   // we need to import/export our code only if the user has specifically
+   // asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+   // libraries to be dynamically linked, or BOOST_DATE_TIME_DYN_LINK
+   // if they want just this one to be dynamically liked:
+#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_DATE_TIME_DYN_LINK)
+      // export if this is our own source, otherwise import:
+#     ifdef BOOST_DATE_TIME_SOURCE
+#       define BOOST_DATE_TIME_DECL __declspec(dllexport)
+#     else
+#       define BOOST_DATE_TIME_DECL __declspec(dllimport)
+#     endif  // BOOST_DATE_TIME_SOURCE
+#  endif  // DYN_LINK
+#endif  // BOOST_HAS_DECLSPEC
+//
+// if BOOST_WHATEVER_DECL isn't defined yet define it now:
+#ifndef BOOST_DATE_TIME_DECL
+#  define BOOST_DATE_TIME_DECL
+#endif
+
+//
+// Automatically link to the correct build variant where possible. 
+// 
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_DATE_TIME_NO_LIB) && !defined(BOOST_DATE_TIME_SOURCE)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_date_time
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_DATE_TIME_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#if defined(BOOST_HAS_THREADS) 
+#  if defined(_MSC_VER) || defined(__MWERKS__) || defined(__MINGW32__) ||  defined(__BORLANDC__)
+     //no reentrant posix functions (eg: localtime_r)
+#  elif (!defined(__hpux) || (defined(__hpux) && defined(_REENTRANT)))
+#   define BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
+#  endif
+#endif
+
+
+#endif

data/ext/boost/date_time/constrained_value.hpp

@@ -0,0 +1,98 @@
+#ifndef CONSTRAINED_VALUE_HPP___
+#define CONSTRAINED_VALUE_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 
+ * $Date: 2008-02-27 15:00:24 -0500 (Wed, 27 Feb 2008) $
+ */
+
+#include <boost/config.hpp>
+
+namespace boost {
+
+//! Namespace containing constrained_value template and types
+namespace CV {
+  //! Represent a min or max violation type
+  enum violation_enum {min_violation, max_violation};
+  
+  //! A template to specify a constrained basic value type
+  /*! This template provides a quick way to generate
+   *  an integer type with a constrained range.  The type
+   *  provides for the ability to specify the min, max, and
+   *  and error handling policy.
+   *  
+   *  <b>value policies</b>
+   *  A class that provides the range limits via the min and
+   *  max functions as well as a function on_error that 
+   *  determines how errors are handled.  A common strategy
+   *  would be to assert or throw and exception.  The on_error
+   *  is passed both the current value and the new value that
+   *  is in error.
+   *
+   */
+  template<class value_policies>
+  class constrained_value {
+  public:
+    typedef typename value_policies::value_type value_type;
+    //    typedef except_type exception_type;
+    constrained_value(value_type value) 
+    {
+      assign(value);
+    };
+    constrained_value& operator=(value_type v) 
+    { 
+      assign(v); 
+      return *this;
+    }   
+    //! Return the max allowed value (traits method)
+    static value_type max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();};
+    //! Return the min allowed value (traits method)
+    static value_type min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();};
+    //! Coerce into the representation type
+    operator value_type() const {return value_;};
+  protected:
+    value_type value_;
+  private:
+    void assign(value_type value)
+    {
+      //adding 1 below gets rid of a compiler warning which occurs when the 
+      //min_value is 0 and the type is unsigned....
+      if (value+1 < (min)()+1) {
+        value_policies::on_error(value_, value, min_violation);
+        return;
+      }
+      if (value > (max)()) {
+        value_policies::on_error(value_, value, max_violation);
+        return;
+      }
+      value_ = value;
+
+    }
+};
+
+  //! Template to shortcut the constrained_value policy creation process
+  template<typename rep_type, rep_type min_value, 
+           rep_type max_value, class exception_type>
+  class simple_exception_policy
+  {
+  public:
+    typedef rep_type value_type;
+    static rep_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; };
+    static rep_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value;};
+    static void on_error(rep_type, rep_type, violation_enum)
+    {
+      throw exception_type();
+    }
+  };
+
+
+
+} } //namespace CV
+
+
+
+
+#endif