[Boost-commit] svn:boost r39827 - in sandbox/committee/LWG/ref_impl: . test

From: jeff_at_[hidden]
Date: 2007-10-08 23:43:44

Author: az_sw_dude
Date: 2007-10-08 23:43:43 EDT (Mon, 08 Oct 2007)
New Revision: 39827
URL: http://svn.boost.org/trac/boost/changeset/39827

Log:
add reference implementation directories + latest date-time code
Added:
   sandbox/committee/LWG/ref_impl/
   sandbox/committee/LWG/ref_impl/date_time   (contents, props changed)
   sandbox/committee/LWG/ref_impl/test/
   sandbox/committee/LWG/ref_impl/test/test_datetime.cpp   (contents, props changed)

Added: sandbox/committee/LWG/ref_impl/date_time
==============================================================================
--- (empty file)
+++ sandbox/committee/LWG/ref_impl/date_time	2007-10-08 23:43:43 EDT (Mon, 08 Oct 2007)
@@ -0,0 +1,388 @@
+/* Copyright (c) 2007 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0  
+ * http://www.boost.org/LICENSE-1.0
+ */
+
+
+// date_time
+
+#ifndef _DATE_TIME__
+#define _DATE_TIME__
+
+#include <stdint.h>   //for precise int types
+#include <sys/time.h> //for gettimeofday and timeval
+
+namespace std {
+
+class hiresolution_clock;
+
+
+template<class traits_type, class final_type>
+class basic_time_duration 
+{
+public:
+ typedef typename traits_type::count_type count_type;
+
+ basic_time_duration(count_type count=0) :
+   m_count(count)
+ {}
+ final_type operator-() const
+ {
+   return final_type(-m_count);
+ }
+ bool operator==(const basic_time_duration& rhs) const
+ {
+   return m_count == rhs.m_count;
+ }
+ bool operator!=(const basic_time_duration& rhs) const
+ {
+   return m_count != rhs.m_count;
+ }
+ bool operator>(const basic_time_duration& rhs) const
+ {
+   return m_count > rhs.m_count;
+ }
+ bool operator>=(const basic_time_duration& rhs) const
+ {
+   return m_count >= rhs.m_count;
+ }
+ bool operator<(const basic_time_duration& rhs) const
+ {
+   return m_count < rhs.m_count;
+ }
+ bool operator<=(const basic_time_duration& rhs) const
+ {
+   return m_count <= rhs.m_count;
+ }
+ final_type operator+(const final_type& rhs) const
+ {
+   return final_type(m_count + rhs.m_count);
+ }
+ final_type& operator+=(const final_type& rhs)
+ {
+   m_count += rhs.m_count;
+   //safe downcast to final subtype
+   return *static_cast<final_type*>(this);
+ }
+ final_type operator-(const final_type& rhs) const
+ {
+   return final_type(m_count - rhs.m_count);    
+ }
+ final_type& operator-=(const final_type& rhs) 
+ {
+   m_count -= rhs.m_count;
+   //safe downcast to final subtype
+   return *static_cast<final_type*>(this);
+ }
+ count_type get_count() const
+ {
+   return m_count;
+ }
+protected:
+ count_type m_count;
+
+};
+
+template<class traits_type, class final_type>
+class subsecond_time_duration : public basic_time_duration<traits_type, final_type>
+{
+public:
+ typedef typename traits_type::count_type count_type;
+
+ subsecond_time_duration(count_type count) :
+   basic_time_duration<traits_type, final_type>(count)
+ {}
+
+ static count_type ticks_per_second()
+ {
+   return traits_type::ticks_per_second;
+ }
+ static bool is_subsecond() 
+ {
+   return true;
+ }
+};
+
+
+template<class traits_type, class final_type>
+class supersecond_time_duration : public basic_time_duration<traits_type, final_type>
+{
+public:
+ typedef typename traits_type::count_type count_type;
+
+ supersecond_time_duration(count_type count) :
+   basic_time_duration<traits_type, final_type>(count)
+ {}
+
+ static count_type seconds_per_tick()
+ {
+   return traits_type::seconds_per_tick;
+ }
+ static bool is_subsecond() 
+ {
+   return false;
+ }
+};
+
+
+struct seconds_traits 
+{
+ typedef int64_t count_type;
+ static const count_type seconds_per_tick = 1;
+};
+
+struct minutes_traits 
+{
+ typedef int64_t count_type;
+ static const count_type seconds_per_tick = 60;
+};
+
+struct hours_traits 
+{
+ typedef int64_t count_type;
+ static const count_type seconds_per_tick = 3600;
+};
+
+struct milliseconds_traits 
+{
+ typedef int64_t count_type;
+ static const count_type ticks_per_second = 1000;
+};
+
+struct microseconds_traits 
+{
+ typedef int64_t count_type;
+ static const count_type ticks_per_second = 1000000;
+};
+
+
+struct nanoseconds_traits 
+{
+ typedef int64_t count_type;
+ static const count_type ticks_per_second = 1000000000;
+};
+
+
+
+//class seconds;
+//class nanoseconds;
+
+
+class nanoseconds : public  subsecond_time_duration<nanoseconds_traits, nanoseconds> 
+{
+public:
+ nanoseconds(nanoseconds_traits::count_type ns) :
+   subsecond_time_duration<nanoseconds_traits, nanoseconds>(ns)
+ {}
+
+};
+
+class microseconds : public  subsecond_time_duration<microseconds_traits, microseconds> 
+{
+public:
+ microseconds(microseconds_traits::count_type ms) :
+   subsecond_time_duration<microseconds_traits, microseconds>(ms)
+ {}
+
+ operator nanoseconds() const
+ {
+   return nanoseconds(m_count*nanoseconds::ticks_per_second()/microseconds::ticks_per_second());
+ }
+
+};
+
+class milliseconds : public  subsecond_time_duration<milliseconds_traits, milliseconds> 
+{
+public:
+ milliseconds(milliseconds_traits::count_type ms) :
+   subsecond_time_duration<milliseconds_traits, milliseconds>(ms)
+ {}
+
+ operator nanoseconds() const
+ {
+   return nanoseconds(m_count*nanoseconds::ticks_per_second()/milliseconds::ticks_per_second());
+ }
+ operator microseconds() const
+ {
+   return microseconds(m_count*microseconds::ticks_per_second()/milliseconds::ticks_per_second());
+ }
+
+};
+
+
+class  seconds : public supersecond_time_duration<seconds_traits, seconds> 
+{
+public:
+ seconds(seconds_traits::count_type s) :
+   supersecond_time_duration<seconds_traits, seconds>(s)
+ {}
+ operator nanoseconds() const
+ {
+   return nanoseconds(m_count*nanoseconds::ticks_per_second());
+ }
+ operator microseconds() const
+ {
+   return microseconds(m_count*microseconds::ticks_per_second());
+ }
+ operator milliseconds() const
+ {
+   return milliseconds(m_count*milliseconds::ticks_per_second());
+ }
+};
+
+
+class  minutes : public supersecond_time_duration<minutes_traits, minutes> 
+{
+public:
+ minutes(minutes_traits::count_type s) :
+   supersecond_time_duration<minutes_traits, minutes>(s)
+ {}
+ operator nanoseconds() const
+ {
+   return nanoseconds(m_count*nanoseconds::ticks_per_second()*minutes::seconds_per_tick());
+ }
+ operator microseconds() const
+ {
+   return microseconds(m_count*minutes::seconds_per_tick()*microseconds::ticks_per_second());
+ }
+ operator milliseconds() const
+ {
+   return milliseconds(m_count*minutes::seconds_per_tick()*milliseconds::ticks_per_second());
+ }
+ operator seconds() const
+ {
+   return seconds(m_count*minutes::seconds_per_tick());
+ }
+};
+
+
+class  hours : public supersecond_time_duration<hours_traits, hours> 
+{
+public:
+ hours(hours_traits::count_type s) :
+   supersecond_time_duration<hours_traits, hours>(s)
+ {}
+ operator nanoseconds() const
+ {
+   return nanoseconds(m_count*nanoseconds::ticks_per_second()*hours::seconds_per_tick());
+ }
+ operator microseconds() const
+ {
+   return microseconds(m_count*hours::seconds_per_tick()*microseconds::ticks_per_second());
+ }
+ operator milliseconds() const
+ {
+   return milliseconds(m_count*hours::seconds_per_tick()*milliseconds::ticks_per_second());
+ }
+ operator seconds() const
+ {
+   return seconds(m_count*hours::seconds_per_tick());
+ }
+ operator minutes() const
+ {
+   return minutes(m_count*hours::seconds_per_tick()/minutes::seconds_per_tick());
+ }
+};
+
+
+class system_time 
+{
+public:
+
+ time_t seconds_since_epoch() const 
+ {
+
+   time_t t = 0;
+   return t; //TODO fixme
+ }
+
+ //The usual operators ==, !=. < >
+
+ bool operator==(const system_time& rhs) const
+ {
+   return m_time == rhs.m_time;
+ }
+ bool operator!=(const system_time& rhs) const
+ {
+   return m_time != rhs.m_time;
+ }
+ bool operator>(const system_time& rhs) const
+ {
+   return m_time > rhs.m_time;
+ }
+ bool operator>=(const system_time& rhs) const
+ {
+   return m_time >= rhs.m_time;
+ }
+ bool operator<(const system_time& rhs) const
+ {
+   return m_time < rhs.m_time;
+ }
+ bool operator<=(const system_time& rhs) const
+ {
+   return m_time <= rhs.m_time;
+ }
+
+ nanoseconds operator-(const system_time& rhs) const
+ {
+   return nanoseconds(m_time-rhs.m_time);
+ }
+
+ template<typename time_duration_type>
+ system_time operator+(const time_duration_type& td) const
+ {
+   nanoseconds ns(td);
+   return system_time(m_time + ns.get_count());
+ }
+ template<typename time_duration_type>
+ system_time& operator+=(const time_duration_type& td)
+ {
+   nanoseconds ns(td);
+   m_time += ns.get_count();
+   return *this;
+ }
+ template<typename time_duration_type>
+ system_time operator-(const time_duration_type& td) const
+ {
+   nanoseconds ns(td);
+   return system_time(m_time-ns.get_count());
+ }
+ template<typename time_duration_type>
+ system_time& operator-=(const time_duration_type& td) 
+ {
+   nanoseconds ns(td);
+   m_time -= ns.get_count();
+   return *this;
+ }
+ int64_t get_rep() const
+ {
+   return m_time;
+ }
+private:
+  friend system_time get_system_time(void);
+
+ system_time(int64_t t) :
+   m_time(t)
+ {}
+ int64_t m_time;
+
+};
+
+
+ inline
+ system_time 
+ get_system_time() 
+ {
+   timeval tv;
+   gettimeofday(&tv, 0); //0 no timezone adjust
+   int64_t time_since_epoch = tv.tv_sec;
+   time_since_epoch *= 1000000000; //make second count into nano seconds
+   time_since_epoch += int64_t(tv.tv_usec) * 1000;
+   return system_time(time_since_epoch);
+ }
+
+
+}
+
+#endif

Added: sandbox/committee/LWG/ref_impl/test/test_datetime.cpp
==============================================================================
--- (empty file)
+++ sandbox/committee/LWG/ref_impl/test/test_datetime.cpp	2007-10-08 23:43:43 EDT (Mon, 08 Oct 2007)
@@ -0,0 +1,110 @@
+
+//g++-4.0 -I ../ test_datetime.cpp -o test_date
+
+
+#include <date_time>
+#include <iostream>
+
+using std::system_time;
+using std::seconds;
+using std::minutes;
+using std::hours;
+using std::milliseconds;
+using std::microseconds;
+using std::nanoseconds;
+
+
+void do_conversions()
+{
+  {
+    minutes m(1);
+    seconds s(m);
+    std::cout << m.get_count() << " minute is " << s.get_count() << " seconds" << std::endl;
+  }
+
+  {
+    hours h(1);
+    seconds s(h);
+    std::cout << h.get_count() << " hour is " << s.get_count() << " seconds" << std::endl;
+  }
+
+  {
+    hours h(1);
+    minutes m(h);
+    std::cout << h.get_count() << " hour is " << m.get_count() << " minutes" << std::endl;
+  }
+
+  {
+    seconds s(1);
+    milliseconds ms(s);
+    std::cout << s.get_count()  << " second is " 
+              << ms.get_count() << " milli seconds" << std::endl;
+  }
+  {
+    seconds s(1);
+    microseconds ms(s);
+    std::cout << s.get_count()  << " second is " 
+              << ms.get_count() << " micro seconds" << std::endl;
+  }
+
+  {
+    seconds s(1);
+    nanoseconds ns(s);
+    std::cout << s.get_count()  << " second is " 
+              << ns.get_count() << " nano seconds" << std::endl;
+  }
+
+
+};
+
+
+
+int
+main()
+{
+
+  system_time now = std::get_system_time();
+  
+  //nanosec since 1-1-1970
+  std::cout << now.get_rep() << std::endl;
+
+  system_time later = now + nanoseconds(5);
+  std::cout << later.get_rep() << std::endl;
+  later = now + seconds(10);
+  std::cout << later.get_rep() << std::endl;
+
+
+  nanoseconds ns(5);
+  ns += nanoseconds(3);
+  ns = -ns;
+
+  std::cout << ns.get_count() << std::endl;
+
+  nanoseconds ns2 = std::get_system_time() - now;
+  std::cout << ns2.get_count() << std::endl;
+
+
+  nanoseconds ns3 = nanoseconds(3) + microseconds(3) - seconds(3);
+  std::cout << ns3.get_count() << std::endl;
+
+  //  nanoseconds ns4 = seconds(3) + nanoseconds(2); //illegal
+  
+  seconds s(1);
+  seconds s2 = s + seconds(3) + seconds(5);
+  std::cout << s2.get_count() << std::endl;
+
+  system_time now2 = std::get_system_time();
+  std::cout << "now2:       " <<  now2.get_rep() << std::endl;
+  now2 += seconds(1);
+  std::cout << "now2 + 1s:  " <<  now2.get_rep() << std::endl;
+  now2 += minutes(1);
+  std::cout << "now2 + 1m:  " <<  now2.get_rep() << std::endl;
+  now2 += milliseconds(1);
+  std::cout << "now2 + 1ms: " <<  now2.get_rep() << std::endl;
+
+
+  do_conversions();
+  
+  return 0;
+
+}