BVB Source Codes

mars Show int_adapter.hpp Source code

Return Download mars: download int_adapter.hpp Source code - Download mars Source code - Type:.hpp
  1. #ifndef _DATE_TIME_INT_ADAPTER_HPP__
  2. #define _DATE_TIME_INT_ADAPTER_HPP__
  3.  
  4. /* Copyright (c) 2002,2003 CrystalClear Software, Inc.
  5.  * Use, modification and distribution is subject to the
  6.  * Boost Software License, Version 1.0. (See accompanying
  7.  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  8.  * Author: Jeff Garland, Bart Garst
  9.  * $Date$
  10.  */
  11.  
  12.  
  13. #include "boost/config.hpp"
  14. #include "boost/limits.hpp" //work around compilers without limits
  15. #include "boost/date_time/special_defs.hpp"
  16. #include "boost/date_time/locale_config.hpp"
  17. #ifndef BOOST_DATE_TIME_NO_LOCALE
  18. #  include <ostream>
  19. #endif
  20.  
  21. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  22. namespace date_time {
  23.  
  24.  
  25. //! Adapter to create integer types with +-infinity, and not a value
  26. /*! This class is used internally in counted date/time representations.
  27.  *  It adds the floating point like features of infinities and
  28.  *  not a number. It also provides mathmatical operations with
  29.  *  consideration to special values following these rules:
  30.  *@code
  31.  *  +infinity  -  infinity  == Not A Number (NAN)
  32.  *   infinity  *  non-zero  == infinity
  33.  *   infinity  *  zero      == NAN
  34.  *  +infinity  * -integer   == -infinity
  35.  *   infinity  /  infinity  == NAN
  36.  *   infinity  *  infinity  == infinity
  37.  *@endcode
  38.  */
  39. template<typename int_type_>
  40. class int_adapter {
  41. public:
  42.   typedef int_type_ int_type;
  43.   int_adapter(int_type v) :
  44.     value_(v)
  45.   {}
  46.   static bool has_infinity()
  47.   {
  48.     return  true;
  49.   }
  50.   static const int_adapter  pos_infinity()
  51.   {
  52.     return (::std::numeric_limits<int_type>::max)();
  53.   }
  54.   static const int_adapter  neg_infinity()
  55.   {
  56.     return (::std::numeric_limits<int_type>::min)();
  57.   }
  58.   static const int_adapter  not_a_number()
  59.   {
  60.     return (::std::numeric_limits<int_type>::max)()-1;
  61.   }
  62.   static  int_adapter max BOOST_PREVENT_MACRO_SUBSTITUTION ()
  63.   {
  64.     return (::std::numeric_limits<int_type>::max)()-2;
  65.   }
  66.   static  int_adapter min BOOST_PREVENT_MACRO_SUBSTITUTION ()
  67.   {
  68.     return (::std::numeric_limits<int_type>::min)()+1;
  69.   }
  70.   static int_adapter from_special(special_values sv)
  71.   {
  72.     switch (sv) {
  73.     case not_a_date_time: return not_a_number();
  74.     case neg_infin:       return neg_infinity();
  75.     case pos_infin:       return pos_infinity();
  76.     case max_date_time:   return (max)();
  77.     case min_date_time:   return (min)();
  78.     default:              return not_a_number();
  79.     }
  80.   }
  81.   static bool is_inf(int_type v)
  82.   {
  83.     return (v == neg_infinity().as_number() ||
  84.             v == pos_infinity().as_number());
  85.   }
  86.   static bool is_neg_inf(int_type v)
  87.   {
  88.     return (v == neg_infinity().as_number());
  89.   }
  90.   static bool is_pos_inf(int_type v)
  91.   {
  92.     return (v == pos_infinity().as_number());
  93.   }
  94.   static bool is_not_a_number(int_type v)
  95.   {
  96.     return (v == not_a_number().as_number());
  97.   }
  98.   //! Returns either special value type or is_not_special
  99.   static special_values to_special(int_type v)
  100.   {
  101.     if (is_not_a_number(v)) return not_a_date_time;
  102.     if (is_neg_inf(v)) return neg_infin;
  103.     if (is_pos_inf(v)) return pos_infin;
  104.     return not_special;
  105.   }
  106.  
  107.   //-3 leaves room for representations of infinity and not a date
  108.   static  int_type maxcount()
  109.   {
  110.     return (::std::numeric_limits<int_type>::max)()-3;
  111.   }
  112.   bool is_infinity() const
  113.   {
  114.     return (value_ == neg_infinity().as_number() ||
  115.             value_ == pos_infinity().as_number());
  116.   }
  117.   bool is_pos_infinity()const
  118.   {
  119.     return(value_ == pos_infinity().as_number());
  120.   }
  121.   bool is_neg_infinity()const
  122.   {
  123.     return(value_ == neg_infinity().as_number());
  124.   }
  125.   bool is_nan() const
  126.   {
  127.     return (value_ == not_a_number().as_number());
  128.   }
  129.   bool is_special() const
  130.   {
  131.     return(is_infinity() || is_nan());
  132.   }
  133.   bool operator==(const int_adapter& rhs) const
  134.   {
  135.     return (compare(rhs) == 0);
  136.   }
  137.   bool operator==(const int& rhs) const
  138.   {
  139.     // quiets compiler warnings
  140.     bool is_signed = std::numeric_limits<int_type>::is_signed;
  141.     if(!is_signed)
  142.     {
  143.       if(is_neg_inf(value_) && rhs == 0)
  144.       {
  145.         return false;
  146.       }
  147.     }
  148.     return (compare(rhs) == 0);
  149.   }
  150.   bool operator!=(const int_adapter& rhs) const
  151.   {
  152.     return (compare(rhs) != 0);
  153.   }
  154.   bool operator!=(const int& rhs) const
  155.   {
  156.     // quiets compiler warnings
  157.     bool is_signed = std::numeric_limits<int_type>::is_signed;
  158.     if(!is_signed)
  159.     {
  160.       if(is_neg_inf(value_) && rhs == 0)
  161.       {
  162.         return true;
  163.       }
  164.     }
  165.     return (compare(rhs) != 0);
  166.   }
  167.   bool operator<(const int_adapter& rhs) const
  168.   {
  169.     return (compare(rhs) == -1);
  170.   }
  171.   bool operator<(const int& rhs) const
  172.   {
  173.     // quiets compiler warnings
  174.     bool is_signed = std::numeric_limits<int_type>::is_signed;
  175.     if(!is_signed)
  176.     {
  177.       if(is_neg_inf(value_) && rhs == 0)
  178.       {
  179.         return true;
  180.       }
  181.     }
  182.     return (compare(rhs) == -1);
  183.   }
  184.   bool operator>(const int_adapter& rhs) const
  185.   {
  186.     return (compare(rhs) == 1);
  187.   }
  188.   int_type as_number() const
  189.   {
  190.     return value_;
  191.   }
  192.   //! Returns either special value type or is_not_special
  193.   special_values as_special() const
  194.   {
  195.     return int_adapter::to_special(value_);
  196.   }
  197.   //creates nasty ambiguities
  198. //   operator int_type() const
  199. //   {
  200. //     return value_;
  201. //   }
  202.  
  203.   /*! Operator allows for adding dissimilar int_adapter types.
  204.    * The return type will match that of the the calling object's type */
  205.   template<class rhs_type>
  206.   inline
  207.   int_adapter operator+(const int_adapter<rhs_type>& rhs) const
  208.   {
  209.     if(is_special() || rhs.is_special())
  210.     {
  211.       if (is_nan() || rhs.is_nan())
  212.       {
  213.         return int_adapter::not_a_number();
  214.       }
  215.       if((is_pos_inf(value_) && rhs.is_neg_inf(rhs.as_number())) ||
  216.       (is_neg_inf(value_) && rhs.is_pos_inf(rhs.as_number())) )
  217.       {
  218.         return int_adapter::not_a_number();
  219.       }
  220.       if (is_infinity())
  221.       {
  222.         return *this;
  223.       }
  224.       if (rhs.is_pos_inf(rhs.as_number()))
  225.       {
  226.         return int_adapter::pos_infinity();
  227.       }
  228.       if (rhs.is_neg_inf(rhs.as_number()))
  229.       {
  230.         return int_adapter::neg_infinity();
  231.       }
  232.     }
  233.     return int_adapter<int_type>(value_ + static_cast<int_type>(rhs.as_number()));
  234.   }
  235.  
  236.   int_adapter operator+(const int_type rhs) const
  237.   {
  238.     if(is_special())
  239.     {
  240.       if (is_nan())
  241.       {
  242.         return int_adapter<int_type>(not_a_number());
  243.       }
  244.       if (is_infinity())
  245.       {
  246.         return *this;
  247.       }
  248.     }
  249.     return int_adapter<int_type>(value_ + rhs);
  250.   }
  251.  
  252.   /*! Operator allows for subtracting dissimilar int_adapter types.
  253.    * The return type will match that of the the calling object's type */
  254.   template<class rhs_type>
  255.   inline
  256.   int_adapter operator-(const int_adapter<rhs_type>& rhs)const
  257.   {
  258.     if(is_special() || rhs.is_special())
  259.     {
  260.       if (is_nan() || rhs.is_nan())
  261.       {
  262.         return int_adapter::not_a_number();
  263.       }
  264.       if((is_pos_inf(value_) && rhs.is_pos_inf(rhs.as_number())) ||
  265.          (is_neg_inf(value_) && rhs.is_neg_inf(rhs.as_number())) )
  266.       {
  267.         return int_adapter::not_a_number();
  268.       }
  269.       if (is_infinity())
  270.       {
  271.         return *this;
  272.       }
  273.       if (rhs.is_pos_inf(rhs.as_number()))
  274.       {
  275.         return int_adapter::neg_infinity();
  276.       }
  277.       if (rhs.is_neg_inf(rhs.as_number()))
  278.       {
  279.         return int_adapter::pos_infinity();
  280.       }
  281.     }
  282.     return int_adapter<int_type>(value_ - static_cast<int_type>(rhs.as_number()));
  283.   }
  284.   int_adapter operator-(const int_type rhs) const
  285.   {
  286.     if(is_special())
  287.     {
  288.       if (is_nan())
  289.       {
  290.         return int_adapter<int_type>(not_a_number());
  291.       }
  292.       if (is_infinity())
  293.       {
  294.         return *this;
  295.       }
  296.     }
  297.     return int_adapter<int_type>(value_ - rhs);
  298.   }
  299.  
  300.   // should templatize this to be consistant with op +-
  301.   int_adapter operator*(const int_adapter& rhs)const
  302.   {
  303.     if(this->is_special() || rhs.is_special())
  304.     {
  305.       return mult_div_specials(rhs);
  306.     }
  307.     return int_adapter<int_type>(value_ * rhs.value_);
  308.   }
  309.   /*! Provided for cases when automatic conversion from
  310.    * 'int' to 'int_adapter' causes incorrect results. */
  311.   int_adapter operator*(const int rhs) const
  312.   {
  313.     if(is_special())
  314.     {
  315.       return mult_div_specials(rhs);
  316.     }
  317.     return int_adapter<int_type>(value_ * rhs);
  318.   }
  319.  
  320.   // should templatize this to be consistant with op +-
  321.   int_adapter operator/(const int_adapter& rhs)const
  322.   {
  323.     if(this->is_special() || rhs.is_special())
  324.     {
  325.       if(is_infinity() && rhs.is_infinity())
  326.       {
  327.         return int_adapter<int_type>(not_a_number());
  328.       }
  329.       if(rhs != 0)
  330.       {
  331.         return mult_div_specials(rhs);
  332.       }
  333.       else { // let divide by zero blow itself up
  334.         return int_adapter<int_type>(value_ / rhs.value_);
  335.       }
  336.     }
  337.     return int_adapter<int_type>(value_ / rhs.value_);
  338.   }
  339.   /*! Provided for cases when automatic conversion from
  340.    * 'int' to 'int_adapter' causes incorrect results. */
  341.   int_adapter operator/(const int rhs) const
  342.   {
  343.     if(is_special() && rhs != 0)
  344.     {
  345.       return mult_div_specials(rhs);
  346.     }
  347.     return int_adapter<int_type>(value_ / rhs);
  348.   }
  349.  
  350.   // should templatize this to be consistant with op +-
  351.   int_adapter operator%(const int_adapter& rhs)const
  352.   {
  353.     if(this->is_special() || rhs.is_special())
  354.     {
  355.       if(is_infinity() && rhs.is_infinity())
  356.       {
  357.         return int_adapter<int_type>(not_a_number());
  358.       }
  359.       if(rhs != 0)
  360.       {
  361.         return mult_div_specials(rhs);
  362.       }
  363.       else { // let divide by zero blow itself up
  364.         return int_adapter<int_type>(value_ % rhs.value_);
  365.       }
  366.     }
  367.     return int_adapter<int_type>(value_ % rhs.value_);
  368.   }
  369.   /*! Provided for cases when automatic conversion from
  370.    * 'int' to 'int_adapter' causes incorrect results. */
  371.   int_adapter operator%(const int rhs) const
  372.   {
  373.     if(is_special() && rhs != 0)
  374.     {
  375.       return mult_div_specials(rhs);
  376.     }
  377.     return int_adapter<int_type>(value_ % rhs);
  378.   }
  379. private:
  380.   int_type value_;
  381.  
  382.   //! returns -1, 0, 1, or 2 if 'this' is <, ==, >, or 'nan comparison' rhs
  383.   int compare(const int_adapter& rhs)const
  384.   {
  385.     if(this->is_special() || rhs.is_special())
  386.     {
  387.       if(this->is_nan() || rhs.is_nan()) {
  388.         if(this->is_nan() && rhs.is_nan()) {
  389.           return 0; // equal
  390.         }
  391.         else {
  392.           return 2; // nan
  393.         }
  394.       }
  395.       if((is_neg_inf(value_) && !is_neg_inf(rhs.value_)) ||
  396.          (is_pos_inf(rhs.value_) && !is_pos_inf(value_)) )
  397.         {
  398.           return -1; // less than
  399.         }
  400.       if((is_pos_inf(value_) && !is_pos_inf(rhs.value_)) ||
  401.          (is_neg_inf(rhs.value_) && !is_neg_inf(value_)) ) {
  402.         return 1; // greater than
  403.       }
  404.     }
  405.     if(value_ < rhs.value_) return -1;
  406.     if(value_ > rhs.value_) return 1;
  407.     // implied-> if(value_ == rhs.value_)
  408.     return 0;
  409.   }
  410.   /* When multiplying and dividing with at least 1 special value
  411.    * very simmilar rules apply. In those cases where the rules
  412.    * are different, they are handled in the respective operator
  413.    * function. */
  414.   //! Assumes at least 'this' or 'rhs' is a special value
  415.   int_adapter mult_div_specials(const int_adapter& rhs)const
  416.   {
  417.     int min_value;
  418.     // quiets compiler warnings
  419.     bool is_signed = std::numeric_limits<int_type>::is_signed;
  420.     if(is_signed) {
  421.       min_value = 0;
  422.     }
  423.     else {
  424.       min_value = 1;// there is no zero with unsigned
  425.     }
  426.     if(this->is_nan() || rhs.is_nan()) {
  427.       return int_adapter<int_type>(not_a_number());
  428.     }
  429.     if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) {
  430.         return int_adapter<int_type>(pos_infinity());
  431.     }
  432.     if((*this > 0 && rhs < min_value) || (*this < min_value && rhs > 0)) {
  433.         return int_adapter<int_type>(neg_infinity());
  434.     }
  435.     //implied -> if(this->value_ == 0 || rhs.value_ == 0)
  436.     return int_adapter<int_type>(not_a_number());
  437.   }
  438.   /* Overloaded function necessary because of special
  439.    * situation where int_adapter is instantiated with
  440.    * 'unsigned' and func is called with negative int.
  441.    * It would produce incorrect results since 'unsigned'
  442.    * wraps around when initialized with a negative value */
  443.   //! Assumes 'this' is a special value
  444.   int_adapter mult_div_specials(const int& rhs) const
  445.   {
  446.     int min_value;
  447.     // quiets compiler warnings
  448.     bool is_signed = std::numeric_limits<int_type>::is_signed;
  449.     if(is_signed) {
  450.       min_value = 0;
  451.     }
  452.     else {
  453.       min_value = 1;// there is no zero with unsigned
  454.     }
  455.     if(this->is_nan()) {
  456.       return int_adapter<int_type>(not_a_number());
  457.     }
  458.     if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) {
  459.         return int_adapter<int_type>(pos_infinity());
  460.     }
  461.     if((*this > 0 && rhs < 0) || (*this < min_value && rhs > 0)) {
  462.         return int_adapter<int_type>(neg_infinity());
  463.     }
  464.     //implied -> if(this->value_ == 0 || rhs.value_ == 0)
  465.     return int_adapter<int_type>(not_a_number());
  466.   }
  467.  
  468. };
  469.  
  470. #ifndef BOOST_DATE_TIME_NO_LOCALE
  471.   /*! Expected output is either a numeric representation
  472.    * or a special values representation.<BR>
  473.    * Ex. "12", "+infinity", "not-a-number", etc. */
  474.   //template<class charT = char, class traits = std::traits<charT>, typename int_type>
  475.   template<class charT, class traits, typename int_type>
  476.   inline
  477.   std::basic_ostream<charT, traits>&
  478.   operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
  479.   {
  480.     if(ia.is_special()) {
  481.       // switch copied from date_names_put.hpp
  482.       switch(ia.as_special())
  483.         {
  484.       case not_a_date_time:
  485.         os << "not-a-number";
  486.         break;
  487.       case pos_infin:
  488.         os << "+infinity";
  489.         break;
  490.       case neg_infin:
  491.         os << "-infinity";
  492.         break;
  493.       default:
  494.         os << "";
  495.       }
  496.     }
  497.     else {
  498.       os << ia.as_number();
  499.     }
  500.     return os;
  501.   }
  502. #endif
  503.  
  504.  
  505. } } //namespace date_time
  506.  
  507.  
  508.  
  509. #endif
  510.  
downloadint_adapter.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top