<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>N2328=07-0188 - Proposal for Date-Time Types in C++0x To Support Threading
  APIs</title><meta name="generator" content="DocBook XSL Stylesheets V1.68.1">

<style type="text/css">
/*=============================================================================
    Copyright (c) 2004 Joel de Guzman
    http://spirit.sourceforge.net/

    Distributed under the Boost Software License, Version 1.0. (See accompany-
    ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

/*=============================================================================
    Body defaults
=============================================================================*/

    body 
    {
        margin: 1em;
        font-family: sans-serif;
    }

/*=============================================================================
    Paragraphs
=============================================================================*/

    p 
    {
        text-align: left;
        font-size: 10pt; 
        line-height: 1.15;
    }

/*=============================================================================
    Program listings
=============================================================================*/

    /* Code on paragraphs */
    p tt.computeroutput
    {
        font-size: 9pt;
    }

    pre.synopsis
    {
        font-size: 90%;
        margin: 1pc 4% 0pc 4%;
        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
    }

    .programlisting, 
    .screen
    {
        font-size: 9pt;
        display: block;
        margin: 1pc 4% 0pc 4%;
        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
    }

    /* Program listings in tables don't get borders */
    td .programlisting, 
    td .screen
    {
        margin: 0pc 0pc 0pc 0pc;
        padding:  0pc 0pc 0pc 0pc;
    }

/*=============================================================================
    Headings
=============================================================================*/

    h1, h2, h3, h4, h5, h6 
    { 
        text-align: left; 
        margin: 1em 0em 0.5em 0em;
        font-weight: bold;
    }

    h1 { font: 140% }
    h2 { font: bold 140% }
    h3 { font: bold 130% }
    h4 { font: bold 120% }
    h5 { font: italic 110% }
    h6 { font: italic 100% }

    /* Top page titles */
    title, 
    h1.title, 
    h2.title
    h3.title, 
    h4.title, 
    h5.title, 
    h6.title, 
    .refentrytitle
    {
        font-weight: bold;
        margin-bottom: 1pc;
    }

    h1.title { font-size: 140% }
    h2.title { font-size: 140% }
    h3.title { font-size: 130% }
    h4.title { font-size: 120% }
    h5.title { font-size: 110% }
    h6.title { font-size: 100% }

    .section h1 
    {
        margin: 0em 0em 0.5em 0em;
        font-size: 140%;
    }

    .section h2 { font-size: 140% }
    .section h3 { font-size: 130% }
    .section h4 { font-size: 120% }
    .section h5 { font-size: 110% }
    .section h6 { font-size: 100% }

    /* Code on titles */
    h1 tt.computeroutput { font-size: 140% }
    h2 tt.computeroutput { font-size: 140% }
    h3 tt.computeroutput { font-size: 130% }
    h4 tt.computeroutput { font-size: 120% }
    h5 tt.computeroutput { font-size: 110% }
    h6 tt.computeroutput { font-size: 100% }

/*=============================================================================
    Author
=============================================================================*/

    h3.author 
    { 
        font-size: 100% 
    }

/*=============================================================================
    Lists
=============================================================================*/

    li
    {
        font-size: 10pt;
        line-height: 1.3;
    }
    
    /* Unordered lists */
    ul 
    {
        text-align: left;
    }
    
    /* Ordered lists */
    ol 
    {
        text-align: left;
    }

/*=============================================================================
    Links
=============================================================================*/

    a
    {
        text-decoration: none; /* no underline */
    }
    
    a:hover
    {
        text-decoration: underline;
    }

/*=============================================================================
    Spirit style navigation
=============================================================================*/

    .spirit-nav
    {
        text-align: right;
    }
    
    .spirit-nav a
    {
        color: white;
        padding-left: 0.5em;
    }
    
    .spirit-nav img
    {
        border-width: 0px;
    }

/*=============================================================================
    Table of contents
=============================================================================*/

    .toc
    {
       margin: 1pc 4% 0pc 4%;
       padding: 0.1pc 1pc 0.1pc 1pc;
       font-size: 80%; 
       line-height: 1.15;
    }
    
    .boost-toc
    {
       float: right;
       padding: 0.5pc;
    }

/*=============================================================================
    Tables
=============================================================================*/

    .table-title, 
    div.table p.title
    {
        margin-left: 4%;
        padding-right: 0.5em; 
        padding-left: 0.5em;
    }
    
    .informaltable table, 
    .table table
    {
        width: 92%;
        margin-left: 4%;
        margin-right: 4%;
    }
    
    div.informaltable table, 
    div.table table
    {
        padding: 4px;
    }
    
    /* Table Cells */
    div.informaltable table tr td, 
    div.table table tr td
    {
        padding: 0.5em;
        text-align: left;
        font-size: 9pt;
    }

    div.informaltable table tr th, 
    div.table table tr th
    {
        padding: 0.5em 0.5em 0.5em 0.5em;
        border: 1pt solid white;
        font-size: 80%;
    }

/*=============================================================================
    Blurbs
=============================================================================*/

    div.note,
    div.tip,
    div.important,
    div.caution,
    div.warning,
    p.blurb
    {
        font-size: 9pt; /* A little bit smaller than the main text */
        line-height: 1.2;
        display: block;
        margin: 1pc 4% 0pc 4%;
        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
    }
    
    p.blurb img
    {
        padding: 1pt;
    }

/*=============================================================================
    Variable Lists
=============================================================================*/

    /* Make the terms in definition lists bold */
    div.variablelist dl dt,
    span.term
    {
        font-weight: bold;
        font-size: 10pt;
    }

    div.variablelist table tbody tr td
    {
        text-align: left;
        vertical-align: top;
        padding: 0em 2em 0em 0em;
        font-size: 10pt;
        margin: 0em 0em 0.5em 0em;
        line-height: 1;
    }

    div.variablelist dl dt
    {
        margin-bottom: 0.2em;
    }

    div.variablelist dl dd
    {
        margin: 0em 0em 0.5em 2em;
        font-size: 10pt;
    }

    div.variablelist table tbody tr td p,
    div.variablelist dl dd p
    {
        margin: 0em 0em 0.5em 0em;
        line-height: 1;
    }

/*=============================================================================
    Misc
=============================================================================*/

    /* Title of books and articles in bibliographies */
    span.title
    {
        font-style: italic;
    }

    span.underline
    {
        text-decoration: underline;
    }

    span.strikethrough
    {
        text-decoration: line-through;
    }

    /* Copyright, Legal Notice */
    div div.legalnotice p
    {
        text-align: left
    }

/*=============================================================================
    Colors
=============================================================================*/

    @media screen
    {
    /* Links */
        a
        {
            color: #005a9c;
        }
    
        a:visited
        {
            color: #9c5a9c;
        }

        h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
        h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
        h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
        {
            text-decoration: none; /* no underline */
            color: #000000;
        }
    
    /* Syntax Highlighting */
        .keyword        { color: #0000AA; }
        .identifier     { color: #000000; }
        .special        { color: #707070; }
        .preprocessor   { color: #402080; }
        .char           { color: teal; }
        .comment        { color: #800000; }
        .string         { color: teal; }
        .number         { color: teal; }
        .white_bkd      { background-color: #FFFFFF; }
        .dk_grey_bkd    { background-color: #999999; }
    
    /* Copyright, Legal Notice */
        .copyright      
        { 
            color: #666666; 
            font-size: small; 
        }
    
        div div.legalnotice p
        {
            color: #666666;
        }
    
    /* Program listing */
        pre.synopsis
        {
            border: 1px solid #DCDCDC;
        }
    
        .programlisting, 
        .screen
        {
            border: 1px solid #DCDCDC;
        }
    
        td .programlisting, 
        td .screen
        {
            border: 0px solid #DCDCDC;
        }
    
    /* Blurbs */
        div.note,
        div.tip,
        div.important,
        div.caution,
        div.warning,
        p.blurb
        {
            border: 1px solid #DCDCDC;
        }
    
    /* Table of contents */
        .toc
        {
            border: 1px solid #DCDCDC;
        }
    
    /* Tables */
        div.informaltable table tr td, 
        div.table table tr td
        {
            border: 1px solid #DCDCDC;
        }
    
        div.informaltable table tr th, 
        div.table table tr th
        {
            background-color: #F0F0F0;
            border: 1px solid #DCDCDC;
        }
    
    /* Misc */
        span.highlight
        {
            color: #00A000;
        }
    }
    
    @media print
    {
    /* Links */
        a
        {
            color: black;
        }
    
        a:visited
        {
            color: black;
        }
    
        .spirit-nav
        {
            display: none;
        }
    
    /* Program listing */
        pre.synopsis
        {
            border: 1px solid gray;
        }
    
        .programlisting, 
        .screen
        {
            border: 1px solid gray;
        }
    
        td .programlisting, 
        td .screen
        {
            border: 0px solid #DCDCDC;
        }
    
    /* Table of contents */
        .toc
        {
            border: 1px solid gray;
        }
    
        .informaltable table, 
        .table table
        {
            border: 1px solid gray;
            border-collapse: collapse;
        }
    
    /* Tables */
        div.informaltable table tr td, 
        div.table table tr td
        {
            border: 1px solid gray;
        }
    
        div.informaltable table tr th, 
        div.table table tr th
        {
            border: 1px solid gray;
        }
    
    /* Misc */
        span.highlight
        {
            font-weight: bold;
        }
    }

/*=============================================================================
    Images
=============================================================================*/

    span.inlinemediaobject img
    {
        vertical-align: middle;
    }
</style>


</head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="article" lang="en"><div class="titlepage"><div><div><h2 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis"></a>N2328=07-0188 - Proposal for Date-Time Types in C++0x To Support Threading
  APIs</h2></div><div><div class="author"><h3 class="author"><span class="firstname">Jeff </span> <span class="surname">Garland (jeff-at-crystalclearsoftware.com)</span></h3></div></div><div><p class="copyright">Copyright  2007 CrystalClear Software, Inc -- Date: 2007-06-23</p></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.introduction">Introduction</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.overview_of_new_types_and_functions">Overview of New Types and Functions</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.design_decisions">Design Decisions</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.issues">Issues</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text">Proposed Text</a></span></dt><dd><dl><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.header__date_time__synopsis">Header &lt;date_time&gt; Synopsis</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_utc_time">class utc_time</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.template_class_hiresolution_clock">template class hiresolution_clock</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.common_duration_functions">Common Duration Functions</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_nanoseconds">class nanoseconds</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_microseconds">class microseconds</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_milliseconds">class milliseconds</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_seconds">class seconds</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_minutes">class minutes</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_hours">class hours</a></span></dt></dl></dd><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.acknowledgements">Acknowledgements</a></span></dt><dt><span class="section"><a href="#n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.references">References</a></span></dt></dl></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.introduction"></a>Introduction</h2></div></div></div><p>
      This paper proposes a set of date-time types to support sophisticated temporal
      interfaces for threading in the next C++ standard. The intent is to replace
      xtime types in proposal <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2285.html" target="_top">N2285</a>
      and its successors (N2320) while giving a smooth evolution path to a full date-time
      library in TR2 as outlined in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1900.pdf" target="_top">N1900</a>
      and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2058.html" target="_top">N2058</a>.
      Most of the elements of this proposal are fully implemented as part of the
      <a href="http://www.boost.org/libs/date_time/index.html" target="_top">Boost Date-Time
      Library</a>. A draft implementation of the proposal is available at <a href="http://www.crystalclearsoftware.com/libraries/date_time/n2328_impl.tar.gz" target="_top">n2328_impl.tar.gz</a>.
    </p><p>
      Overall, the goal is to support code like this:
    </p><pre class="programlisting">
<span class="identifier">std</span><span class="special">::</span><span class="identifier">this_thread</span><span class="special">::</span><span class="identifier">sleep</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">seconds</span><span class="special">(</span><span class="number">1</span><span class="special">));</span>

<span class="identifier">Lock</span> <span class="identifier">l</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">condition</span><span class="special">::</span><span class="identifier">timed_wait</span><span class="special">(</span><span class="identifier">l</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">microseconds</span><span class="special">(</span><span class="number">100</span><span class="special">));</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">recursive_timed_mutex</span> <span class="identifier">rtm</span><span class="special">;</span>
<span class="identifier">rtm</span><span class="special">.</span><span class="identifier">timed_lock</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">milliseconds</span><span class="special">(</span><span class="number">20</span><span class="special">));</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">utc_time</span> <span class="identifier">now</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hiresolution_clock</span><span class="special">::</span><span class="identifier">universal_time</span><span class="special">();</span>
<span class="identifier">now</span> <span class="special">+=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nanoseconds</span><span class="special">(</span><span class="number">500</span><span class="special">);</span>


<span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_lock</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">&gt;</span> <span class="identifier">lk</span><span class="special">(</span><span class="identifier">mut</span><span class="special">);</span>
<span class="comment">// Wait for 2 seconds on a condition variable
</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">utc_time</span> <span class="identifier">time_out</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hiresolution_clock</span><span class="special">::</span><span class="identifier">universal_time</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">seconds</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="special">{</span>
     <span class="keyword">bool</span> <span class="identifier">timed_out</span> <span class="special">=</span> <span class="special">!</span><span class="identifier">cv</span><span class="special">.</span><span class="identifier">timed_wait</span><span class="special">(</span><span class="identifier">lk</span><span class="special">,</span> <span class="identifier">time_out</span><span class="special">);</span>
     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">timed_out</span><span class="special">)</span>
         <span class="comment">// deal with time out
</span><span class="special">}</span>
</pre></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.overview_of_new_types_and_functions"></a>Overview of New Types and Functions</h2></div></div></div><p>
      This proposal introduces 3 kinds of types into the standard. These are
    </p><div class="itemizedlist"><ul type="disc"><li>
        time point
      </li><li>
        time duration(s)
      </li><li>
        clock
      </li></ul></div><p>
      A time point represents an instant in the time continuum (dimensionless). A
      time duration is a length of time unattached to a any time point. Time durations
      are signed. A clock type is an interface to a device that can return a time
      point. These three types work together to provide a high level programming
      interface for C++ developers.
    </p><p>
      Time durations and time points operate much like built-in integers except that
      their purpose is to provide calculations in time. To behave like built-int
      types they provide all of the usual valuetype concepts including: EqualityComparable,
      LessThanComparable, CopyConstructable, DefaultConstructable, and Assignable.
      Duration types are behave like signed integers while time points are more like
      unsiged integers.
    </p><p>
      Table 2 summarizes the types introduced in the proposal.
    </p><div class="informaltable"><h4><a name="id224284"></a>
        <span class="table-title">Type Overview</span>
      </h4><table border="1"><colgroup><col><col><col></colgroup><thead><tr><th>description</th><th>type</th><th>Notes</th></tr></thead><tbody><tr><td>utc_time</td><td>time point</td><td>Point in time
            representing a nanosecond resolution time. Epoch for UTC time is same
            as time_t 1970-01-01 00:00:00.000000000 </td></tr><tr><td>hiresolution_clock</td><td>clock</td><td>Clock that
            can produce the current utc_time.</td></tr><tr><td>hours</td><td>time duration</td><td>Duration type
            that represents a count of hours.</td></tr><tr><td>minutes</td><td>time duration</td><td>Duration type
            that represents a count of minutes.</td></tr><tr><td>seconds</td><td>time duration</td><td>Duration type
            that represents a count of seconds.</td></tr><tr><td>milliseconds</td><td>time duration</td><td>Duration
            type that represents a count of milliseconds.</td></tr><tr><td>microseconds</td><td>time duration</td><td>Duration
            type that represents a count of microseconds.</td></tr><tr><td>nanoseconds</td><td>time duration</td><td>Duration
            type that represents a count of nanoseconds.</td></tr></tbody></table></div><p>
      utc_time is a simple time_point type that can be used to represent a current
      time much like time_t but with nanosecond resolution. It represents a time
      in UTC (Coordinated Universal Time). UTC is a widely used standard based on
      the solar time at the Prime Meridian (formerly known as Greenwich Mean Time-GMT).
      The utc_time class works in conjunction with the hiresolution_clock to provide
      the current time. The various duration types provide for specification and
      calculations with utc_time.
    </p><p>
      These temporal types form the foundation for enabling sophisticated calculations
      using dates and times and well defined. For example, no matter the resolution
      of time points and durations we can say that the following calculations apply
      where --&gt; means 'results in'. Note that date-time calculations should be
      free from 'floating point round-off'.
    </p><div class="informaltable"><h4><a name="id265724"></a>
        <span class="table-title">Calculation Results and Typing</span>
      </h4><table border="1"><colgroup><col><col></colgroup><thead><tr><th>Rule --&gt; Result Type</th><th>Notes</th></tr></thead><tbody><tr><td>Timepoint + Duration --&gt; Timepoint</td><td>Valid only
            for timepoints of equal or greater resolution than the Duration.</td></tr><tr><td>Timepoint - Duration --&gt; Timepoint</td><td>Valid only
            for timepoints of equal or greater resolution than the Duration.</td></tr><tr><td>Timepoint - Timepoint --&gt; Duration</td><td>Timepoints
            of the same resolution only.</td></tr><tr><td>Duration + Duration --&gt; Duration</td><td>In mixed resolution
            durations, higher resolution duration must the result.</td></tr><tr><td>Duration - Duration --&gt; Duration</td><td>In mixed resolution
            durations, higher resolution duration must the result.</td></tr><tr><td>Duration * Integer --&gt; Duration</td><td>Results in a
            duration.</td></tr><tr><td>Integer * Duration --&gt; Duration</td><td>Results in a
            duration.</td></tr><tr><td>Duration / Integer --&gt; Duration</td><td>Integer Division
            rules.</td></tr><tr><td>Duration + Timepoint --&gt; Timepoint</td><td>Valid only
            for timepoints of equal or greater resolution than the Duration.</td></tr><tr><td>Duration - Timepoint --&gt; Undefined</td><td>Compilation
            error.</td></tr><tr><td>Timepoint + Timepoint --&gt; Undefined</td><td>Compilation
            error.</td></tr></tbody></table></div><p>
      As an example, we can see that these rules support code like this:
    </p><pre class="programlisting">
<span class="comment">//duration based calculations
</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nanoseconds</span> <span class="identifier">ns</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nanoseconds</span><span class="special">(</span><span class="number">3</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">microseconds</span><span class="special">(</span><span class="number">3</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">seconds</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">ns</span> <span class="special">+=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nanoseconds</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">ns</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">ns</span><span class="special">;</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">utc_time</span> <span class="identifier">now</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hiresolution_clock</span><span class="special">::</span><span class="identifier">universal_time</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">seconds</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">now</span> <span class="special">+=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">nanoseconds</span><span class="special">(</span><span class="number">500</span><span class="special">);</span>
</pre><p>
      Conversion between duration types is either automatic or results in a compilation
      error if the conversion would result in a loss of resolution. This is illustrated
      below:
    </p><pre class="programlisting">
<span class="identifier">std</span><span class="special">::</span><span class="identifier">hours</span> <span class="identifier">h</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">h</span> <span class="special">+=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">minutes</span><span class="special">(</span><span class="number">10</span><span class="special">);</span> <span class="comment">//compile error -- loss of resolution
</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">minutes</span> <span class="identifier">m</span><span class="special">;</span>
<span class="identifier">m</span> <span class="special">+=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hours</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>    <span class="comment">//ok, hours can be converted to minutes
</span><span class="keyword">if</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">minutes</span><span class="special">(</span><span class="number">60</span><span class="special">)</span> <span class="special">&gt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">hours</span><span class="special">(</span><span class="number">1</span><span class="special">))</span> <span class="comment">//ok, returns false
</span></pre><p>
      To support the needed resolution conversions all time points and durations
      provide resolution trait information. For time durations less than one second
      the traits provide information to allow conversion to seconds. For time durations
      greater than one second the traits provide the number of seconds in a duration.
    </p><p>
      This proposal provides some support for conversion to and from C time types.
      In particular utc_time can be constructed from a time_t and can provide a time_t
      value by calling seconds_since_epoch. This seemingly minimal interface provides
      enough capability for interaction with C and other non-native programs for
      time handling.
    </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.design_decisions"></a>Design Decisions</h2></div></div></div><p>
      This proposal provides just enough C compatibility to allow users to convert
      to and from C types -- primarily time_t. The introduction of additional C interfaces
      or a broader interface raises many hard to resolve issues with the current
      C APIs and distracts from the intent of this proposal which is to provide support
      for a rich time interfaces to support multi-threading.
    </p><p>
      The utc_time class is a very minimal time_point type type as compared to the
      primary timepoint (datetime) specified for the TR2 proposal. This is intended
      to keep this proposal for C++0x as small as possible and focused on support
      for threading.
    </p><p>
      The proposal provides no input-output functions whereas the TR2 proposal has
      an extensive input-output specification. This is a simplification to keep the
      proposal minimal. Before TR2 becomes available, users can convert the types
      in this proposal to fundamental types to perform input-output.
    </p><p>
      This proposal, like the TR2 proposal, is careful to separate the representation
      of a point in time from the clock types that measure a point in time. This
      decision has several significant advantages as outlined in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1900.pdf" target="_top">N1900</a>.
    </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.issues"></a>Issues</h2></div></div></div><p>
      Although utc_time is specified with a resolution of nanoseconds most platforms
      do not provide hardware and operating system support this resolution. Typical
      modern platforms can support clock resolutions of microseconds. This proposal
      does not mandate a particular clock resolution requirement.
    </p><p>
      Since the tr2 proposal will likely use a different namespace for time types
      (either tr2 or tr2::datetime), this may create some confusion since the duration
      types proposed here will already be in namespace std.
    </p><p>
      It's unclear if Datetime should become it's own chapter or just extend section
      20.7 which is the current date and time section under General utilities library.
    </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text"></a>Proposed Text</h2></div></div></div><p>
      Text in notes is meant as explanatory information about the proposal. It is
      not to be added to the standard.
    </p><div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Note</h3><p>
        This is an example of a note that is NOT part of the standard text.
      </p></div><p>
      All dates and times in this proposal are supplied in ISO extended form unless
      otherwise specified. Specifically year-month-day hour:minute:second.fractional_seconds.
      So the 15th day of September 2006 is specified as <code class="code"><span class="number">2006</span><span class="special">-</span><span class="number">09</span><span class="special">-</span><span class="number">15</span></code>.
    </p><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.chapter__tbs____datetime_library"></a><h2><a name="id266561"></a>
      Chapter (tbs) - Datetime Library
    </h2><p>
      This clause contains components that C++ programs may use to manipulate dates,
      times, and timezones.
    </p><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.fw_2_definitions"></a><h2><a name="id266578"></a>
      FW.2 Definitions
    </h2><p>
      Time Point: An instant in the time continuum (dimensionless).
    </p><p>
      Time Duration: A length of time unattached to a any time point. Time durations
      have an assigned maximum resolution (eg: 1 second).
    </p><p>
      Epoch: The start of a given time scale. For time_t the epoch is 1970-01-01
      00:00:00. In this text the epoch may be called a 'minimum date' or 'minimum
      time'.
    </p><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.header__date_time__synopsis"></a>Header &lt;date_time&gt; Synopsis</h3></div></div></div><pre class="programlisting">
<span class="keyword">namespace</span> <span class="identifier">std</span> 
<span class="special">{</span>

  <span class="comment">//duration types
</span>  <span class="keyword">class</span>    <span class="identifier">hours</span><span class="special">;</span>
  <span class="keyword">class</span>    <span class="identifier">minutes</span><span class="special">;</span>
  <span class="keyword">class</span>    <span class="identifier">seconds</span><span class="special">;</span>
  <span class="keyword">class</span>    <span class="identifier">milliseconds</span><span class="special">;</span>
  <span class="keyword">class</span>    <span class="identifier">microseconds</span><span class="special">;</span>
  <span class="keyword">class</span>    <span class="identifier">nanoseconds</span><span class="special">;</span>

  <span class="comment">//timepoint   
</span>  <span class="keyword">class</span> <span class="identifier">utc_time</span><span class="special">;</span>

  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">time_type</span><span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">hiresolution_clock</span><span class="special">;</span>
</pre></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_utc_time"></a>class utc_time</h3></div></div></div><pre class="programlisting">
<span class="keyword">class</span> <span class="identifier">utc_time</span> 
<span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>

  <span class="identifier">utc_time</span><span class="special">();</span> <span class="comment">//epoch
</span>  <span class="identifier">utc_time</span><span class="special">(</span><span class="identifier">time_t</span><span class="special">,</span> <span class="identifier">nanoseconds</span> <span class="identifier">ns</span><span class="special">);</span>
  <span class="special">~</span><span class="identifier">utc_time</span><span class="special">();</span>

  <span class="identifier">time_t</span> <span class="identifier">seconds_since_epoch</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">nanoseconds</span> <span class="identifier">nanoseconds_since_epoch</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

  <span class="comment">//traits 
</span>  <span class="keyword">typedef</span> <span class="char">'implementation defined'</span> <span class="identifier">tick_type</span><span class="special">;</span>
  <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
  <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
  <span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>

  <span class="comment">//comparison functions
</span>  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>

  <span class="comment">//arithmetic functions
</span>  <span class="identifier">nanoseconds</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span>

  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
  <span class="identifier">utc_time</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>

  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
  <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">);</span>

  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
  <span class="identifier">utc_time</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>

  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
  <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">)</span> 

<span class="special">};</span>
</pre><p>
        The class utc_time provides a timepoint that represents the current UTC time.
        utc_time must provide a minimum range of 1970-01-01 00:00:00.000000000 +
        292 years. This represents the number of nanoseconds that can be represented
        in a signed 64 bit integer.
      </p><pre class="programlisting">
<span class="identifier">utc_time</span><span class="special">();</span> <span class="comment">//epoch
</span></pre><p>
        <span class="emphasis"><em>Effects: Construct a utc_time representing the epoch time point
        1970-01-01 00:00:00.000000000</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">utc_time</span><span class="special">(</span><span class="identifier">time_t</span><span class="special">,</span> <span class="identifier">nanoseconds</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Construct a utc time where time_t represents seconds since
        1970-01-01 00:00:00.000000000 and nanaoseconds provides an additional nanosecond
        offset</em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: If the total nanoseconds &gt; 1 second the seconds are
        incremented appropriately</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="special">~</span><span class="identifier">utc_time</span><span class="special">();</span> 
</pre><p>
        <span class="emphasis"><em>Effects: Destroys the time point.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">time_t</span> <span class="identifier">seconds_since_epoch</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns the count of seconds since 1970-01-01 00:00:00.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">nanoseconds</span> <span class="identifier">nanoseconds_since_epoch</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns the count of seconds since 1970-01-01 00:00:00.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns 1000000000</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns 0</em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: Since this is a subsecond type it returns 0 for seconds_per_tick</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: true.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if rhs is the same time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if rhs is not the same time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if time is greater than rhs time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if time is greater or equal than rhs time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if time is less than rhs time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if time is less than rhs time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">nanoseconds</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns the difference between two times in a nanosecond
        count.</em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: If rhs is greater the result will be a negative nanosecond
        count.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
<span class="identifier">utc_time</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns the duration converted to nanosecond resolution
        and added to the time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
<span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Convert the duration to nanosecond resolution add to nanoseconds
        to the time.</em></span>
      </p><p>
        <span class="emphasis"><em>Returns: Modified value of this.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
<span class="identifier">utc_time</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns the duration converted to nanosecond resolution
        and subtracted from the time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">time_duration_type</span><span class="special">&gt;</span>
<span class="identifier">utc_time</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">time_duration_type</span><span class="special">&amp;</span> <span class="identifier">td</span><span class="special">)</span> 
</pre><p>
        <span class="emphasis"><em>Effects: Convert the duration to nanosecond resolution subtract
        from the time and return *this.</em></span>
      </p><p>
        <span class="emphasis"><em>Returns: Modified value of this.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.template_class_hiresolution_clock"></a>template class hiresolution_clock</h3></div></div></div><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">time_type</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">hiresolution_clock</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="keyword">static</span> <span class="identifier">time_type</span> <span class="identifier">universal_time</span><span class="special">();</span>
<span class="special">};</span>
</pre><p>
        The hiresolution_clock provides access to the operating system clock at a
        resolution up to nanoseconds. The actual resolution will vary from platform
        to platform.
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">time_type</span> <span class="identifier">universal_time</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: Current UTC time - equvalent of time_t with fractional
        sections.</em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: Function is thread-safe on platforms supporting threading.
        Successive calls to this function will produce and equal or greater time
        value in all cases. </em></span>
      </p><div class="note" style="margin-left: 0.5in; margin-right: 0.5in;"><h3 class="title">Note</h3><p>
          Typical modern platforms personal computer platforms achieve microsecond
          level resolution from calls to the clock. The <a href="http://www.boost.org/libs/date_time/index.html" target="_top">Boost
          Date-Time Library</a> has a class that portably implements the proposed
          interface, but it uses different C-level interfaces depending on the operating
          system.
        </p></div><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.common_duration_functions"></a>Common Duration Functions</h3></div></div></div><p>
        The following functions are common functions to all durations types. These
        functions provide the basis for durations to be EqualityComparable, LessThanComparable
        as well as the usual aritmetic operations. In the following text duration_type
        refers to the containing duration type.
      </p><pre class="programlisting">
<span class="keyword">class</span> <span class="identifier">duration_type</span> <span class="special">{</span> <span class="comment">//where duration_type== nanoseconds, microseconds, etc
</span>
    <span class="comment">//comparison operators
</span>    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span>  <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span>  <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span>


    <span class="comment">//sign inversion
</span>    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">-()</span> <span class="keyword">const</span>

    <span class="comment">//arithmetic operations
</span>    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">-</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="keyword">const</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">+</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="keyword">const</span>

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span>

    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">/</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">divisor</span><span class="special">)</span> <span class="keyword">const</span>
    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">int</span> <span class="identifier">divisor</span><span class="special">)</span> 
    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">*</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span>
    <span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">int</span> <span class="identifier">divisor</span><span class="special">)</span> 

    <span class="identifier">tick_type</span> <span class="identifier">get_count</span><span class="special">()</span> <span class="keyword">const</span> 
</pre><p>
        The following details each of these functions.
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if rhs duration is greater.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if rhs is not the same time.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if the rhs duration is larger.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if greater or equal than the rhs duration.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if less than the rhs duration.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><p>
        <span class="emphasis"><em>Returns: Returns true if less or equal to the rhs duration.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="comment">//sign inversion
</span><span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">-()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: Negated value of the duration.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="comment">//arithmetic operations
</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">-</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: A duration value equal to this-rhs_duration.</em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: This will fail to compiler if the rhs_duration_type is
        of higher resolution.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span>
</pre><p>
        <span class="emphasis"><em>Effects: Modifies to value equal to this-rhs_duration. </em></span>
      </p><p>
        <span class="emphasis"><em>Returns: this </em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: This will fail to compiler if the rhs_duration_type is
        of higher resolution.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">+</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: Duration equal to this+rhs_duration. </em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: This will fail to compiler if the rhs_duration_type is
        of higher resolution.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">rhs_duration_type</span><span class="special">&gt;</span>
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">rhs_duration_type</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span>
</pre><p>
        <span class="emphasis"><em>Effects: Modifies to value equal to this+rhs_duration. </em></span>
      </p><p>
        <span class="emphasis"><em>Returns: this </em></span>
      </p><p>
        <span class="emphasis"><em>Remarks: This will fail to compiler if the rhs_duration_type is
        of higher resolution.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">/</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">divisor</span><span class="special">)</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: Duration with value equal to this/divisor according to
        integer arithmetic rules.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">int</span> <span class="identifier">divisor</span><span class="special">)</span> 
</pre><p>
        <span class="emphasis"><em>Effects: Change value of this by this/divisor according to integer
        arithmetic rules.</em></span>
      </p><p>
        <span class="emphasis"><em>Returns: this </em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">*</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">)</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: Duration with value equal to this*rhs </em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">duration_type</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">)</span> 
</pre><p>
        <span class="emphasis"><em>Effects: Modifies to value equal to this*rhs. </em></span>
      </p><p>
        <span class="emphasis"><em>Returns: this </em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">tick_type</span> <span class="identifier">get_count</span><span class="special">()</span> <span class="keyword">const</span> 
</pre><p>
        <span class="emphasis"><em>Returns: Returns the count at the resolution of the time duration
        type.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_nanoseconds"></a>class nanoseconds</h3></div></div></div><pre class="programlisting">
<span class="keyword">class</span> <span class="identifier">nanoseconds</span> 
<span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>

   <span class="identifier">nanoseconds</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
   <span class="identifier">nanoseconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">nanoseconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
   <span class="special">~</span><span class="identifier">nanoseconds</span><span class="special">();</span>

   <span class="comment">//traits information
</span>   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
   <span class="keyword">typedef</span> <span class="char">'implementation-defined'</span> <span class="identifier">tick_type</span><span class="special">;</span>

   <span class="comment">//+ common functions
</span>
<span class="special">;</span>
</pre><p>
        Class nanoseconds represents a count of nanoseconds.
      </p><pre class="programlisting">
<span class="identifier">nanoseconds</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Construct a count of nanoseconds - default is zero.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">nanoseconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">nanoseconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Copy construction.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="special">~</span><span class="identifier">nanoseconds</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Effects: Destruct count.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 1000000000</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 0</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: true</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_microseconds"></a>class microseconds</h3></div></div></div><pre class="programlisting">
<span class="keyword">class</span> <span class="identifier">microseconds</span> 
<span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>

   <span class="identifier">microseconds</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
   <span class="identifier">microseconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">microseconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
   <span class="special">~</span><span class="identifier">microseconds</span><span class="special">();</span>

   <span class="comment">//conversions
</span>   <span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>

   <span class="comment">//traits information
</span>   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
   <span class="keyword">typedef</span> <span class="char">'implementation-defined'</span> <span class="identifier">tick_type</span><span class="special">;</span>

<span class="special">;</span>
</pre><p>
        Class microseconds represents a count of microseconds.
      </p><pre class="programlisting">
<span class="identifier">microseconds</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Construct a count of microseconds - default is zero.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">microseconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">microseconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Copy construction.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="special">~</span><span class="identifier">microseconds</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Effects: Destruct count.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="comment">//conversions
</span><span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: microsecond count converted to nanoseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 1000000</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 0</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: true</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_milliseconds"></a>class milliseconds</h3></div></div></div><pre class="programlisting">
<span class="keyword">class</span> <span class="identifier">milliseconds</span>
<span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>
   <span class="identifier">milliseconds</span><span class="special">(</span><span class="identifier">int_type</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
   <span class="identifier">milliseconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">milliseconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
   <span class="special">~</span><span class="identifier">milliseconds</span><span class="special">();</span>

   <span class="comment">//conversions
</span>   <span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
   <span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

   <span class="comment">//traits information
</span>   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
   <span class="keyword">typedef</span> <span class="char">'implementation-defined'</span> <span class="identifier">tick_type</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
        Class milliseconds represents a count of milliseconds.
      </p><pre class="programlisting">
<span class="identifier">milliseconds</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Construct a count of milliseconds - default is zero.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">milliseconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">milliseconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Copy construction.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="special">~</span><span class="identifier">milliseconds</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Effects: Destruct count.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: millisecond count converted to nanoseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: millisecond count converted to microseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 1000</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 0</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: true</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_seconds"></a>class seconds</h3></div></div></div><pre class="programlisting">
<span class="keyword">class</span>  <span class="identifier">seconds</span> 
<span class="special">{</span> 
 <span class="keyword">public</span><span class="special">:</span>
   <span class="identifier">seconds</span><span class="special">(</span><span class="identifier">int_type</span> <span class="identifier">s</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
   <span class="identifier">seconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">seconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
   <span class="special">~</span><span class="identifier">seconds</span><span class="special">();</span>

   <span class="comment">//conversions
</span>   <span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">milliseconds</span><span class="special">()</span> <span class="keyword">const</span>

   <span class="comment">//traits information
</span>   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
   <span class="keyword">typedef</span> <span class="char">'implementation-defined'</span> <span class="identifier">tick_type</span><span class="special">;</span>

<span class="special">};</span>
</pre><p>
        Class seconds represents a count of seconds.
      </p><pre class="programlisting">
<span class="identifier">seconds</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Construct a count of seconds - default is zero.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">seconds</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">seconds</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Copy construction.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="special">~</span><span class="identifier">seconds</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Effects: Destruct count.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: second count converted to nanoseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: second count converted to microseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">milliseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: second count converted to milliseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 1</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 1</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: false</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_minutes"></a>class minutes</h3></div></div></div><pre class="programlisting">
<span class="keyword">class</span>  <span class="identifier">minutes</span> 
<span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>
   <span class="identifier">minutes</span><span class="special">(</span><span class="identifier">int_type</span> <span class="identifier">s</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
   <span class="identifier">minutes</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">minutes</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
   <span class="special">~</span><span class="identifier">minutes</span><span class="special">();</span>

   <span class="comment">//conversions
</span>   <span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">milliseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">seconds</span><span class="special">()</span> <span class="keyword">const</span>

   <span class="comment">//traits information
</span>   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
   <span class="keyword">typedef</span> <span class="char">'implementation-defined'</span> <span class="identifier">tick_type</span><span class="special">;</span>

<span class="special">};</span>
</pre><p>
        Class minutes represents a count of minutes.
      </p><pre class="programlisting">
<span class="identifier">minutes</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Construct a count of minutes - default is zero.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">minutes</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">minutes</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Copy construction.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="special">~</span><span class="identifier">minutes</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Effects: Destruct count.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: minute count converted to nanoseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: minute count converted to microseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">milliseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: minute count converted to milliseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">seconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: minute count converted to seconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 0</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 60</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: false</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.proposed_text.class_hours"></a>class hours</h3></div></div></div><pre class="programlisting">
<span class="keyword">class</span>  <span class="identifier">hours</span> 
<span class="special">{</span>
 <span class="keyword">public</span><span class="special">:</span>
   <span class="identifier">hours</span><span class="special">(</span><span class="identifier">int_type</span> <span class="identifier">s</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
   <span class="identifier">hours</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">hours</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
   <span class="special">~</span><span class="identifier">hours</span><span class="special">();</span>

   <span class="comment">//conversions
</span>   <span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">milliseconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">seconds</span><span class="special">()</span> <span class="keyword">const</span>
   <span class="keyword">operator</span> <span class="identifier">minutes</span><span class="special">()</span> <span class="keyword">const</span>

   <span class="comment">//traits information
</span>   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
   <span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
   <span class="keyword">typedef</span> <span class="char">'implementation-defined'</span> <span class="identifier">tick_type</span><span class="special">;</span>

<span class="special">};</span>
</pre><p>
        Class hours represents a count of hours.
      </p><pre class="programlisting">
<span class="identifier">hours</span><span class="special">(</span><span class="keyword">long</span> <span class="keyword">long</span><span class="special">=</span><span class="number">0</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Construct a count of hours - default is zero.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="identifier">hours</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">hours</span><span class="special">&amp;</span> <span class="identifier">rhs</span><span class="special">);</span>
</pre><p>
        <span class="emphasis"><em>Effects: Copy construction.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="special">~</span><span class="identifier">hours</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Effects: Destruct count.</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">nanoseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: hour count converted to nanoseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">microseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: hour count converted to microseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">milliseconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: hour count converted to milliseconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">seconds</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: hour count converted to seconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">operator</span> <span class="identifier">minutes</span><span class="special">()</span> <span class="keyword">const</span>
</pre><p>
        <span class="emphasis"><em>Returns: hour count converted to seconds</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">ticks_per_second</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 0</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="identifier">tick_type</span> <span class="identifier">seconds_per_tick</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: 3600</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p><pre class="programlisting">
<span class="keyword">static</span> <span class="keyword">bool</span> <span class="identifier">is_subsecond</span><span class="special">();</span>
</pre><p>
        <span class="emphasis"><em>Returns: false</em></span>
      </p><p>
        <span class="emphasis"><em>Throws: Nothing</em></span>
      </p></div></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.acknowledgements"></a>Acknowledgements</h2></div></div></div><p>
      First thanks goes to the Boost Community for all the constructive suggestions
      for evolving <a href="http://www.boost.org/libs/date_time/index.html" target="_top">Boost
      Date-Time Library</a> into a great C++ date-time library. Thanks to Howard
      Hinnant for taking and interest and helping mold this into a reasonable proposal.
      Special thanks goes to my family for allowing me to work on this.
    </p></div><div class="section" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="n2328_07_0188___proposal_for_date_time_types_in_c__0x_to_support_threading_apis.references"></a>References</h2></div></div></div><div class="itemizedlist"><ul type="disc"><li><a href="http://www.boost.org/libs/date_time/index.html" target="_top">Boost Date-Time
        Library</a></li><li><a href="http://www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=40874" target="_top">ISO
        8601:2004 Data elements and interchange formats -- Information interchange
        -- Representation of dates and times</a></li></ul></div></div></div></body></html>
