passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_weekday.hpp

@@ -1,7 +1,7 @@
 #ifndef GREG_WEEKDAY_HPP___
 #define GREG_WEEKDAY_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003,2020 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)
@@ -38,21 +38,55 @@ namespace gregorian {
 
 
   //! Represent a day within a week (range 0==Sun to 6==Sat)
-  class BOOST_DATE_TIME_DECL greg_weekday : public greg_weekday_rep {
+  class BOOST_SYMBOL_VISIBLE greg_weekday : public greg_weekday_rep {
   public:
     typedef boost::date_time::weekdays weekday_enum;
-    greg_weekday(value_type day_of_week_num) :
+    BOOST_CXX14_CONSTEXPR greg_weekday(value_type day_of_week_num) :
       greg_weekday_rep(day_of_week_num)
     {}
 
-    value_type as_number() const {return value_;}
-    const char* as_short_string() const;
-    const char* as_long_string()  const;
+    BOOST_CXX14_CONSTEXPR value_type as_number() const {return value_;}
+    BOOST_CXX14_CONSTEXPR weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}
+
+    //! Return a 3 digit english string of the day of week (eg: Sun)
+    const char* as_short_string() const
+    {
+      static const char* const short_weekday_names[]
+        = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+
+      return short_weekday_names[value_];
+    }
+
+    //! Return a point to a long english string representing day of week
+    const char* as_long_string() const
+    {
+      static const char* const long_weekday_names[]
+        = {"Sunday","Monday","Tuesday","Wednesday", "Thursday", "Friday", "Saturday"};
+
+      return long_weekday_names[value_];
+    }
+
+
 #ifndef BOOST_NO_STD_WSTRING
-    const wchar_t* as_short_wstring() const;
-    const wchar_t* as_long_wstring()  const;
+
+    //! Return a 3 digit english wchar_t string of the day of week (eg: Sun)
+    const wchar_t* as_short_wstring() const
+    {
+      static const wchar_t* const w_short_weekday_names[]={L"Sun", L"Mon", L"Tue",
+                                                           L"Wed", L"Thu", L"Fri", L"Sat"};
+      return w_short_weekday_names[value_];
+    }
+
+    //! Return a point to a long english wchar_t string representing day of week
+    const wchar_t* as_long_wstring()  const
+    {
+      static const wchar_t* const w_long_weekday_names[]= {L"Sunday",L"Monday",L"Tuesday",
+                                                           L"Wednesday", L"Thursday",
+                                                           L"Friday", L"Saturday"};
+      return w_long_weekday_names[value_];
+    }
+
 #endif // BOOST_NO_STD_WSTRING
-    weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}
 
 
   };

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/greg_year.hpp

@@ -1,7 +1,7 @@
 #ifndef GREG_YEAR_HPP___
 #define GREG_YEAR_HPP___
 
-/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+/* Copyright (c) 2002,2003, 2020 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)
@@ -39,8 +39,8 @@ namespace gregorian {
   */
   class BOOST_SYMBOL_VISIBLE greg_year : public greg_year_rep {
   public:
-    greg_year(value_type year) : greg_year_rep(year) {}
-    operator value_type()  const {return value_;}
+    BOOST_CXX14_CONSTEXPR greg_year(value_type year) : greg_year_rep(year) {}
+    BOOST_CXX14_CONSTEXPR operator value_type()  const {return value_;}
   };
 
 

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian/parsers.hpp

@@ -9,44 +9,63 @@
  * $Date$
  */
 
-#include "boost/date_time/gregorian/gregorian_types.hpp"
-#include "boost/date_time/date_parsing.hpp"
-#include "boost/date_time/compiler_config.hpp"
-#include "boost/date_time/parse_format_base.hpp"
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <boost/date_time/date_parsing.hpp>
+#include <boost/date_time/compiler_config.hpp>
+#include <boost/date_time/parse_format_base.hpp>
+#include <boost/date_time/special_defs.hpp>
+#include <boost/date_time/find_match.hpp>
 #include <string>
-#include <sstream>
+#include <iterator>
 
 namespace boost {
 namespace gregorian {
 
   //! Return special_value from string argument
-  /*! Return special_value from string argument. If argument is 
-   * not one of the special value names (defined in src/gregorian/names.hpp), 
+  /*! Return special_value from string argument. If argument is
+   * not one of the special value names (defined in names.hpp),
    * return 'not_special' */
-  BOOST_DATE_TIME_DECL special_values special_value_from_string(const std::string& s);
+  inline
+  date_time::special_values
+  special_value_from_string(const std::string& s) {
+    static const char* const special_value_names[date_time::NumSpecialValues]
+      = {"not-a-date-time","-infinity","+infinity","min_date_time",
+         "max_date_time","not_special"};
+
+    short i = date_time::find_match(special_value_names,
+                                    special_value_names,
+                                    date_time::NumSpecialValues,
+                                    s);
+    if(i >= date_time::NumSpecialValues) { // match not found
+      return date_time::not_special;
+    }
+    else {
+      return static_cast<date_time::special_values>(i);
+    }
+  }
 
   //! Deprecated: Use from_simple_string
-  inline date from_string(std::string s) {
+  inline date from_string(const std::string& s) {
     return date_time::parse_date<date>(s);
   }
 
   //! From delimited date string where with order year-month-day eg: 2002-1-25 or 2003-Jan-25 (full month name is also accepted)
-  inline date from_simple_string(std::string s) {
+  inline date from_simple_string(const std::string& s) {
     return date_time::parse_date<date>(s, date_time::ymd_order_iso);
   }
   
   //! From delimited date string where with order year-month-day eg: 1-25-2003 or Jan-25-2003 (full month name is also accepted)
-  inline date from_us_string(std::string s) {
+  inline date from_us_string(const std::string& s) {
     return date_time::parse_date<date>(s, date_time::ymd_order_us);
   }
   
   //! From delimited date string where with order day-month-year eg: 25-1-2002 or 25-Jan-2003 (full month name is also accepted)
-  inline date from_uk_string(std::string s) {
+  inline date from_uk_string(const std::string& s) {
     return date_time::parse_date<date>(s, date_time::ymd_order_dmy);
   }
   
   //! From iso type date string where with order year-month-day eg: 20020125
-  inline date from_undelimited_string(std::string s) {
+  inline date from_undelimited_string(const std::string& s) {
     return date_time::parse_undelimited_date<date>(s);
   }
 

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian_calendar.hpp

@@ -20,10 +20,10 @@ namespace date_time {
       can be used in the creation of date systems or just to perform calculations.
       All the methods of this class are static functions, so the intent is to
       never create instances of this class.
-    @param ymd_type_ Struct type representing the year, month, day.  The ymd_type must
+    @tparam ymd_type_ Struct type representing the year, month, day.  The ymd_type must
            define a of types for the year, month, and day.  These types need to be
            arithmetic types.
-    @param date_int_type_ Underlying type for the date count.  Must be an arithmetic type.
+    @tparam date_int_type_ Underlying type for the date count.  Must be an arithmetic type.
   */
   template<typename ymd_type_, typename date_int_type_>
   class BOOST_SYMBOL_VISIBLE gregorian_calendar_base {
@@ -40,19 +40,18 @@ namespace date_time {
     typedef date_int_type_ date_int_type;
 
 
-    static unsigned short day_of_week(const ymd_type& ymd);
-    static int week_number(const ymd_type&ymd);
-    //static unsigned short day_of_year(date_int_type);
-    static date_int_type day_number(const ymd_type& ymd);
-    static date_int_type julian_day_number(const ymd_type& ymd);
-    static date_int_type modjulian_day_number(const ymd_type& ymd);
-    static ymd_type from_day_number(date_int_type);
-    static ymd_type from_julian_day_number(date_int_type);
-    static ymd_type from_modjulian_day_number(date_int_type);
-    static bool is_leap_year(year_type);
-    static unsigned short end_of_month_day(year_type y, month_type m);
-    static ymd_type epoch();
-    static unsigned short days_in_week();
+    static BOOST_CXX14_CONSTEXPR unsigned short day_of_week(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR int week_number(const ymd_type&ymd);
+    static BOOST_CXX14_CONSTEXPR date_int_type day_number(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR date_int_type julian_day_number(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR date_int_type modjulian_day_number(const ymd_type& ymd);
+    static BOOST_CXX14_CONSTEXPR ymd_type from_day_number(date_int_type);
+    static BOOST_CXX14_CONSTEXPR ymd_type from_julian_day_number(date_int_type);
+    static BOOST_CXX14_CONSTEXPR ymd_type from_modjulian_day_number(date_int_type);
+    static BOOST_CXX14_CONSTEXPR bool is_leap_year(year_type);
+    static BOOST_CXX14_CONSTEXPR unsigned short end_of_month_day(year_type y, month_type m);
+    static BOOST_CXX14_CONSTEXPR ymd_type epoch();
+    static BOOST_CXX14_CONSTEXPR unsigned short days_in_week();
 
   };
 
@@ -60,9 +59,8 @@ namespace date_time {
 
 } } //namespace
 
-#ifndef NO_BOOST_DATE_TIME_INLINE
 #include "boost/date_time/gregorian_calendar.ipp"
-#endif
+
 
 
 

data/src/cxx_supportlib/vendor-modified/boost/date_time/gregorian_calendar.ipp

@@ -6,10 +6,6 @@
  * $Date$
  */
 
-#ifndef NO_BOOST_DATE_TIME_INLINE
-  #undef BOOST_DATE_TIME_INLINE
-  #define BOOST_DATE_TIME_INLINE inline
-#endif
 
 namespace boost {
 namespace date_time {
@@ -17,7 +13,8 @@ namespace date_time {
   /*! Converts a year-month-day into a day of the week number
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   unsigned short
   gregorian_calendar_base<ymd_type_,date_int_type_>::day_of_week(const ymd_type& ymd) {
     unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
@@ -35,7 +32,8 @@ namespace date_time {
     Reference for this algorithm is the Calendar FAQ by Claus Tondering, April 2000.
   */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   int
   gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
     unsigned long julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
@@ -71,7 +69,8 @@ namespace date_time {
   /*! The day number is an absolute number of days since the start of count
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   date_int_type_
   gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd)
   {
@@ -86,7 +85,8 @@ namespace date_time {
   /*! Since this implementation uses julian day internally, this is the same as the day_number.
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   date_int_type_
   gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd)
   {
@@ -98,7 +98,8 @@ namespace date_time {
    *  MJD 0 thus started on 17 Nov 1858(Gregorian) at 00:00:00 UTC
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   date_int_type_
   gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd)
   {
@@ -107,7 +108,8 @@ namespace date_time {
 
   //! Change a day number into a year-month-day
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
   gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber)
   {
@@ -127,7 +129,8 @@ namespace date_time {
 
   //! Change a day number into a year-month-day
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
   gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber)
   {
@@ -147,7 +150,8 @@ namespace date_time {
 
   //! Change a modified julian day number into a year-month-day
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
   gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(date_int_type dayNumber) {
     date_int_type jd = dayNumber + 2400001; //is 2400000.5 prerounded
@@ -159,7 +163,8 @@ namespace date_time {
    *@return true if year is a leap year, false otherwise
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   bool
   gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year)
   {
@@ -172,7 +177,8 @@ namespace date_time {
    *  No error checking is performed.
    */
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   unsigned short
   gregorian_calendar_base<ymd_type_,date_int_type_>::end_of_month_day(year_type year,
                                                                       month_type month)
@@ -183,7 +189,7 @@ namespace date_time {
         return 29;
       } else {
         return 28;
-      };
+      }
     case 4:
     case 6:
     case 9:
@@ -191,13 +197,13 @@ namespace date_time {
       return 30;
     default:
       return 31;
-    };
-
+    }
   }
 
-  //! Provide the ymd_type specification for the calandar start
+  //! Provide the ymd_type specification for the calendar start
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   ymd_type_
   gregorian_calendar_base<ymd_type_,date_int_type_>::epoch()
   {
@@ -206,7 +212,8 @@ namespace date_time {
 
   //! Defines length of a week for week calculations
   template<typename ymd_type_, typename date_int_type_>
-  BOOST_DATE_TIME_INLINE
+  BOOST_CXX14_CONSTEXPR
+  inline
   unsigned short
   gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
   {
@@ -215,5 +222,3 @@ namespace date_time {
 
 
 } } //namespace gregorian
-
-

data/src/cxx_supportlib/vendor-modified/boost/date_time/int_adapter.hpp

@@ -46,34 +46,34 @@ template<typename int_type_>
 class int_adapter {
 public:
   typedef int_type_ int_type;
-  int_adapter(int_type v) :
+  BOOST_CXX14_CONSTEXPR int_adapter(int_type v) :
     value_(v)
   {}
-  static bool has_infinity()
+  static BOOST_CONSTEXPR bool has_infinity()
   {
     return  true;
   }
-  static const int_adapter  pos_infinity()
+  static BOOST_CONSTEXPR int_adapter  pos_infinity()
   {
     return (::std::numeric_limits<int_type>::max)();
   }
-  static const int_adapter  neg_infinity()
+  static BOOST_CONSTEXPR int_adapter  neg_infinity()
   {
     return (::std::numeric_limits<int_type>::min)();
   }
-  static const int_adapter  not_a_number()
+  static BOOST_CONSTEXPR int_adapter  not_a_number()
   {
     return (::std::numeric_limits<int_type>::max)()-1;
   }
-  static  int_adapter max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+  static BOOST_CONSTEXPR int_adapter max BOOST_PREVENT_MACRO_SUBSTITUTION ()
   {
     return (::std::numeric_limits<int_type>::max)()-2;
   }
-  static  int_adapter min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+  static BOOST_CONSTEXPR int_adapter min BOOST_PREVENT_MACRO_SUBSTITUTION ()
   {
     return (::std::numeric_limits<int_type>::min)()+1;
   }
-  static int_adapter from_special(special_values sv)
+  static BOOST_CXX14_CONSTEXPR int_adapter from_special(special_values sv)
   {
     switch (sv) {
     case not_a_date_time: return not_a_number();
@@ -84,25 +84,25 @@ public:
     default:              return not_a_number();
     }
   }
-  static bool is_inf(int_type v)
+  static BOOST_CONSTEXPR bool is_inf(int_type v)
   {
     return (v == neg_infinity().as_number() ||
             v == pos_infinity().as_number());
   }
-  static bool is_neg_inf(int_type v)
+  static BOOST_CXX14_CONSTEXPR bool is_neg_inf(int_type v)
   {
     return (v == neg_infinity().as_number());
   }
-  static bool is_pos_inf(int_type v)
+  static BOOST_CXX14_CONSTEXPR bool is_pos_inf(int_type v)
   {
     return (v == pos_infinity().as_number());
   }
-  static bool is_not_a_number(int_type v)
+  static BOOST_CXX14_CONSTEXPR bool is_not_a_number(int_type v)
   {
     return (v == not_a_number().as_number());
   }
   //! Returns either special value type or is_not_special
-  static special_values to_special(int_type v)
+  static BOOST_CXX14_CONSTEXPR special_values to_special(int_type v)
   {
     if (is_not_a_number(v)) return not_a_date_time;
     if (is_neg_inf(v)) return neg_infin;
@@ -111,36 +111,36 @@ public:
   }
 
   //-3 leaves room for representations of infinity and not a date
-  static  int_type maxcount()
+  static BOOST_CONSTEXPR int_type maxcount()
   {
     return (::std::numeric_limits<int_type>::max)()-3;
   }
-  bool is_infinity() const
+  BOOST_CONSTEXPR bool is_infinity() const
   {
     return (value_ == neg_infinity().as_number() ||
             value_ == pos_infinity().as_number());
   }
-  bool is_pos_infinity()const
+  BOOST_CONSTEXPR bool is_pos_infinity()const
   {
     return(value_ == pos_infinity().as_number());
   }
-  bool is_neg_infinity()const
+  BOOST_CONSTEXPR bool is_neg_infinity()const
   {
     return(value_ == neg_infinity().as_number());
   }
-  bool is_nan() const
+  BOOST_CONSTEXPR bool is_nan() const
   {
     return (value_ == not_a_number().as_number());
   }
-  bool is_special() const
+  BOOST_CONSTEXPR bool is_special() const
   {
     return(is_infinity() || is_nan()); 
   }
-  bool operator==(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator==(const int_adapter& rhs) const
   {
     return (compare(rhs) == 0);
   }
-  bool operator==(const int& rhs) const
+  BOOST_CXX14_CONSTEXPR bool operator==(const int& rhs) const
   {
     if(!std::numeric_limits<int_type>::is_signed)
     {
@@ -151,11 +151,11 @@ public:
     }
     return (compare(rhs) == 0);
   }
-  bool operator!=(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator!=(const int_adapter& rhs) const
   {
     return (compare(rhs) != 0);
   }
-  bool operator!=(const int& rhs) const
+  BOOST_CXX14_CONSTEXPR bool operator!=(const int& rhs) const
   {
     if(!std::numeric_limits<int_type>::is_signed)
     {
@@ -166,11 +166,11 @@ public:
     }
     return (compare(rhs) != 0);
   }
-  bool operator<(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator<(const int_adapter& rhs) const
   {
     return (compare(rhs) == -1);
   }
-  bool operator<(const int& rhs) const
+  BOOST_CXX14_CONSTEXPR bool operator<(const int& rhs) const
   {
     // quiets compiler warnings
     if(!std::numeric_limits<int_type>::is_signed)
@@ -182,16 +182,16 @@ public:
     }
     return (compare(rhs) == -1);
   }
-  bool operator>(const int_adapter& rhs) const
+  BOOST_CONSTEXPR bool operator>(const int_adapter& rhs) const
   {
     return (compare(rhs) == 1);
   }
-  int_type as_number() const
+  BOOST_CONSTEXPR int_type as_number() const
   {
     return value_;
   }
   //! Returns either special value type or is_not_special
-  special_values as_special() const
+  BOOST_CONSTEXPR special_values as_special() const
   {
     return int_adapter::to_special(value_);
   }
@@ -204,7 +204,7 @@ public:
   /*! Operator allows for adding dissimilar int_adapter types.
    * The return type will match that of the the calling object's type */
   template<class rhs_type>
-  inline
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator+(const int_adapter<rhs_type>& rhs) const
   {
     if(is_special() || rhs.is_special())
@@ -234,6 +234,7 @@ public:
     return int_adapter<int_type>(value_ + static_cast<int_type>(rhs.as_number()));
   }
 
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator+(const int_type rhs) const
   {
     if(is_special())
@@ -253,7 +254,7 @@ public:
   /*! Operator allows for subtracting dissimilar int_adapter types.
    * The return type will match that of the the calling object's type */
   template<class rhs_type>
-  inline
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator-(const int_adapter<rhs_type>& rhs)const
   {
     if(is_special() || rhs.is_special())
@@ -282,6 +283,8 @@ public:
     }
     return int_adapter<int_type>(value_ - static_cast<int_type>(rhs.as_number()));
   }
+
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator-(const int_type rhs) const
   {
     if(is_special())
@@ -299,6 +302,7 @@ public:
   }
 
   // should templatize this to be consistant with op +-
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator*(const int_adapter& rhs)const
   {
     if(this->is_special() || rhs.is_special())
@@ -307,8 +311,10 @@ public:
     }
     return int_adapter<int_type>(value_ * rhs.value_);
   }
+
   /*! Provided for cases when automatic conversion from 
    * 'int' to 'int_adapter' causes incorrect results. */
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator*(const int rhs) const
   {
     if(is_special())
@@ -319,6 +325,7 @@ public:
   }
 
   // should templatize this to be consistant with op +-
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator/(const int_adapter& rhs)const
   {
     if(this->is_special() || rhs.is_special())
@@ -332,23 +339,27 @@ public:
         return mult_div_specials(rhs);
       }
       else { // let divide by zero blow itself up
-        return int_adapter<int_type>(value_ / rhs.value_);
+        return int_adapter<int_type>(value_ / rhs.value_); //NOLINT
       }
     }
     return int_adapter<int_type>(value_ / rhs.value_);
   }
+
   /*! Provided for cases when automatic conversion from 
    * 'int' to 'int_adapter' causes incorrect results. */
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator/(const int rhs) const
   {
     if(is_special() && rhs != 0)
     {
       return mult_div_specials(rhs);
     }
-    return int_adapter<int_type>(value_ / rhs);
+    // let divide by zero blow itself up like int
+    return int_adapter<int_type>(value_ / rhs); //NOLINT
   }
 
   // should templatize this to be consistant with op +-
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator%(const int_adapter& rhs)const
   {
     if(this->is_special() || rhs.is_special())
@@ -362,26 +373,31 @@ public:
         return mult_div_specials(rhs);
       }
       else { // let divide by zero blow itself up
-        return int_adapter<int_type>(value_ % rhs.value_);
+        return int_adapter<int_type>(value_ % rhs.value_); //NOLINT
       }
     }
     return int_adapter<int_type>(value_ % rhs.value_);
   }
+
   /*! Provided for cases when automatic conversion from 
    * 'int' to 'int_adapter' causes incorrect results. */
+  BOOST_CXX14_CONSTEXPR
   int_adapter operator%(const int rhs) const
   {
     if(is_special() && rhs != 0)
     {
       return mult_div_specials(rhs);
     }
-    return int_adapter<int_type>(value_ % rhs);
+    // let divide by zero blow itself up
+    return int_adapter<int_type>(value_ % rhs); //NOLINT
   }
+
 private:
   int_type value_;
   
   //! returns -1, 0, 1, or 2 if 'this' is <, ==, >, or 'nan comparison' rhs
-  int compare(const int_adapter& rhs)const
+  BOOST_CXX14_CONSTEXPR
+  int compare( const int_adapter& rhs ) const
   {
     if(this->is_special() || rhs.is_special())
     {
@@ -408,12 +424,14 @@ private:
     // implied-> if(value_ == rhs.value_) 
     return 0;
   }
+
   /* When multiplying and dividing with at least 1 special value
    * very simmilar rules apply. In those cases where the rules
    * are different, they are handled in the respective operator 
    * function. */
   //! Assumes at least 'this' or 'rhs' is a special value
-  int_adapter mult_div_specials(const int_adapter& rhs)const
+  BOOST_CXX14_CONSTEXPR
+  int_adapter mult_div_specials(const int_adapter& rhs) const
   {
     if(this->is_nan() || rhs.is_nan()) {
       return int_adapter<int_type>(not_a_number());
@@ -428,12 +446,14 @@ private:
     //implied -> if(this->value_ == 0 || rhs.value_ == 0)
     return int_adapter<int_type>(not_a_number());
   }
+
   /* Overloaded function necessary because of special
    * situation where int_adapter is instantiated with 
    * 'unsigned' and func is called with negative int.
    * It would produce incorrect results since 'unsigned'
    * wraps around when initialized with a negative value */
   //! Assumes 'this' is a special value
+  BOOST_CXX14_CONSTEXPR
   int_adapter mult_div_specials(const int& rhs) const
   {
     if(this->is_nan()) {
@@ -449,7 +469,7 @@ private:
     //implied -> if(this->value_ == 0 || rhs.value_ == 0)
     return int_adapter<int_type>(not_a_number());
   }
-  
+
 };
 
 #ifndef BOOST_DATE_TIME_NO_LOCALE