comparison DEPENDENCIES/generic/include/boost/chrono/process_cpu_clocks.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 //  boost/chrono/process_cpu_clocks.hpp  -----------------------------------------------------------//
 
 //  Copyright 2009-2011 Vicente J. Botet Escriba
+//  Copyright (c) Microsoft Corporation 2014
 
 //  Distributed under the Boost Software License, Version 1.0.
 //  See http://www.boost.org/LICENSE_1_0.txt
 
 //  See http://www.boost.org/libs/system for documentation.

 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
         static BOOST_CHRONO_INLINE time_point now(system::error_code & ec );
 #endif
     };
 
+#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
     class BOOST_CHRONO_DECL process_user_cpu_clock {
     public:
         typedef nanoseconds                          duration;
         typedef duration::rep                        rep;
         typedef duration::period                     period;

         static BOOST_CHRONO_INLINE time_point now() BOOST_NOEXCEPT;
 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
         static BOOST_CHRONO_INLINE time_point now(system::error_code & ec );
 #endif
     };
+#endif
 
         template <typename Rep>
         struct process_times
             : arithmetic<process_times<Rep>,
             multiplicative<process_times<Rep>, Rep,

               typedef Rep rep;
             process_times()
                 : real(0)
                 , user(0)
                 , system(0){}
+
+#if ! defined BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
             template <typename Rep2>
             explicit process_times(
                 Rep2 r)
                 : real(r)
                 , user(r)
                 , system(r){}
+#endif
             template <typename Rep2>
             explicit process_times(
                 process_times<Rep2> const& rhs)
                 : real(rhs.real)
                 , user(rhs.user)

 
             rep   real;    // real (i.e wall clock) time
             rep   user;    // user cpu time
             rep system;  // system cpu time
 
+#if ! defined BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
             operator rep() const
             {
               return real;
             }
+#endif
             template <typename Rep2>
             bool operator==(process_times<Rep2> const& rhs) {
                 return (real==rhs.real &&
                         user==rhs.user &&
                         system==rhs.system);

             {
                 os <<  "{"<< real <<";"<< user <<";"<< system << "}";
             }
 
             template <class CharT, class Traits>
-            void read(std::basic_istream<CharT, Traits>& is) const
+            void read(std::basic_istream<CharT, Traits>& is)
             {
                 typedef std::istreambuf_iterator<CharT, Traits> in_iterator;
                 in_iterator i(is);
                 in_iterator e;
                 if (i == e || *i != '{')  // mandatory '{'

       duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
   }
 
 
   typedef process_times<nanoseconds::rep> process_cpu_clock_times;
+#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
     class BOOST_CHRONO_DECL process_cpu_clock
     {
     public:
 
         typedef process_cpu_clock_times times;

         static BOOST_CHRONO_INLINE time_point now() BOOST_NOEXCEPT;
 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
         static BOOST_CHRONO_INLINE time_point now(system::error_code & ec );
 #endif
     };
+#endif
 
     template <class CharT, class Traits, typename Rep>
     std::basic_ostream<CharT, Traits>&
     operator<<(std::basic_ostream<CharT, Traits>& os,
         process_times<Rep> const& rhs)

     }
 
     template <class CharT, class Traits, typename Rep>
     std::basic_istream<CharT, Traits>&
     operator>>(std::basic_istream<CharT, Traits>& is,
-        process_times<Rep> const& rhs)
+        process_times<Rep>& rhs)
     {
         rhs.read(is);
         return is;
     }
 

         const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
         return str;
       }
     };
 
+#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
     template<class CharT>
     struct clock_string<process_user_cpu_clock, CharT>
     {
       static std::basic_string<CharT> name()
       {

                 { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'p', 'r', 'o', 'c', 'e', 's', 's', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p' };
         const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
         return str;
       }
     };
+#endif
 
 } // namespace chrono
 } // namespace boost
 
 namespace std {