$include_dir="/home/hyper-archives/boost-commit/include"; include("$include_dir/msg-header.inc") ?>
From: john_at_[hidden]
Date: 2008-03-16 05:48:44
Author: johnmaddock
Date: 2008-03-16 05:48:43 EDT (Sun, 16 Mar 2008)
New Revision: 43648
URL: http://svn.boost.org/trac/boost/changeset/43648
Log:
Added Boost.Thread news.
Text files modified: 
   website/public_html/beta/feed/history.rss              |    92 +++++++++++++++++++++++++++++++++++++++ 
   website/public_html/beta/feed/history/boost_1_35_0.qbk |    42 +++++++++++++++++                       
   website/public_html/beta/feed/news.rss                 |    92 +++++++++++++++++++++++++++++++++++++++ 
   3 files changed, 223 insertions(+), 3 deletions(-)
Modified: website/public_html/beta/feed/history.rss
==============================================================================
--- website/public_html/beta/feed/history.rss	(original)
+++ website/public_html/beta/feed/history.rss	2008-03-16 05:48:43 EDT (Sun, 16 Mar 2008)
@@ -14,7 +14,7 @@
     <h3><span class="link">New Libraries</span></h3>
     <ul>
       <li>
-        <span class="library"><a href="/libs/asio/index.html">ASIO</a>:</span> Portable networking,
+        <span class="library"><a href="/libs/asio/index.html">Asio</a>:</span> Portable networking,
         including sockets, timers, hostname resolution and socket iostreams, from
         Chris Kohlhoff.
       </li>
@@ -100,6 +100,79 @@
         </ul>
       </li>
       <li>
+        <span class="library"><a href="/libs/thread/index.html">Thread</a>:</span>
+        <ul>
+          <li>
+            Instances of boost::thread and of the various lock types are now movable.
+          </li>
+          <li>
+            Threads can be interrupted at interruption points.
+          </li>
+          <li>
+            Condition variables can now be used with any type that implements the
+            Lockable concept, through the use of <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">condition_variable_any</span></code>
+            (<code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">condition</span></code> is a typedef to <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">condition_variable_any</span></code>, provided for
+            backwards compatibility). <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">condition_variable</span></code>
+            is provided as an optimization, and will only work with <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique_lock</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">></span></code>
+            (<code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">::</span><span class="identifier">scoped_lock</span></code>).
+          </li>
+          <li>
+            Thread IDs are separated from boost::thread, so a thread can obtain it's
+            own ID (using <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">this_thread</span><span class="special">::</span><span class="identifier">get_id</span><span class="special">()</span></code>),
+            and IDs can be used as keys in associative containers, as they have the
+            full set of comparison operators.
+          </li>
+          <li>
+            Timeouts are now implemented using the Boost DateTime library, through
+            a typedef <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">system_time</span></code> for absolute timeouts,
+            and with support for relative timeouts in many cases. <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">xtime</span></code>
+            is supported for backwards compatibility only.
+          </li>
+          <li>
+            Locks are implemented as publicly accessible templates <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">lock_guard</span></code>, <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique_lock</span></code>,
+            <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_lock</span></code>, and <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">upgrade_lock</span></code>,
+            which are templated on the type of the mutex. The Lockable concept has
+            been extended to include publicly available <code><span class="identifier">lock</span><span class="special">()</span></code> and <code><span class="identifier">unlock</span><span class="special">()</span></code> member functions, which are used by
+            the lock types.
+          </li>
+          <li>
+            <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">try_mutex</span></code> has been removed, and the
+            functionality subsumed into <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span></code>.
+            <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">try_mutex</span></code> is left as a typedef, but
+            is no longer a separate class.
+          </li>
+          <li>
+            <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">recursive_try_mutex</span></code> has been removed,
+            and the functionality subsumed into <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">recursive_mutex</span></code>.
+            <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">recursive_try_mutex</span></code> is left as a typedef,
+            but is no longer a separate class.
+          </li>
+          <li>
+            <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">thread</span><span class="special">::</span><span class="identifier">lock_ops</span></code> has been removed. Code that
+            relies on the <code><span class="identifier">lock_ops</span></code>
+            implementation detail will no longer work, as this has been removed,
+            as it is no longer necessary now that mutex types now have public <code><span class="identifier">lock</span><span class="special">()</span></code>
+            and <code><span class="identifier">unlock</span><span class="special">()</span></code>
+            member functions.
+          </li>
+          <li>
+            <code><span class="identifier">scoped_lock</span></code> constructors
+            with a second parameter of type bool are no longer provided. With previous
+            boost releases, <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">::</span><span class="identifier">scoped_lock</span>
+            <span class="identifier">some_lock</span><span class="special">(</span><span class="identifier">some_mutex</span><span class="special">,</span><span class="keyword">false</span><span class="special">);</span></code>
+            could be used to create a lock object that was associated with a mutex,
+            but did not lock it on construction. This facility has now been replaced
+            with the constructor that takes a <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">defer_lock_type</span></code>
+            as the second parameter: <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">::</span><span class="identifier">scoped_lock</span>
+            <span class="identifier">some_lock</span><span class="special">(</span><span class="identifier">some_mutex</span><span class="special">,</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">defer_lock</span><span class="special">);</span></code>
+          </li>
+          <li>
+            The broken <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">read_write_mutex</span></code> has been replaced
+            with <code><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_mutex</span></code>.
+          </li>
+        </ul>
+      </li>
+      <li>
         <span class="library"><a href="/libs/wave/index.html">Wave</a>:</span> Standards conformant
         implementation of the mandated C99/C++ preprocessor functionality packed
         behind an easy to use iterator interface, from Hartmut Kaiser. Highlights:
@@ -159,6 +232,23 @@
           </li>
         </ul>
       </li>
+      <li>
+        <span class="library"><a href="/libs/functional/hash/index.html">Hash</a>:</span>
+  A TR1 hash
+        function object, from Daniel James. Highlights:
+        <ul>
+          <li>
+            Support for <code><span class="keyword">long</span> <span class="keyword">long</span></code>,
+            <code><span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span></code>.
+          </li>
+          <li>
+            Improved the algorithm for hashing floating point numbers.
+          </li>
+          <li>
+            A few bug and warning fixes.
+          </li>
+        </ul>
+      </li>
     </ul>
   </div>
   <div id="version_1_35_0.supported_compilers">
Modified: website/public_html/beta/feed/history/boost_1_35_0.qbk
==============================================================================
--- website/public_html/beta/feed/history/boost_1_35_0.qbk	(original)
+++ website/public_html/beta/feed/history/boost_1_35_0.qbk	2008-03-16 05:48:43 EDT (Sun, 16 Mar 2008)
@@ -12,7 +12,7 @@
 
 [section New Libraries]
 
-* [phrase library..[@/libs/asio/index.html ASIO]:] Portable networking, 
+* [phrase library..[@/libs/asio/index.html Asio]:] Portable networking, 
   including sockets, timers, hostname resolution and socket iostreams, 
   from Chris Kohlhoff.
 * [phrase library..[@/libs/bimap/index.html Bimap]:] Boost.Bimap is a 
@@ -59,6 +59,46 @@
     some existing code. See [@/libs/iostreams/doc/index.html?path=12 Release Notes] 
     for details.
   * Numerous other bug fixes and optimizations.
+* [phrase library..[@/libs/thread/index.html Thread]:] 
+    * Instances of boost::thread and of the various lock types are now movable.
+    * Threads can be interrupted at interruption points.
+    * Condition variables can now be used with any type that implements the
+   Lockable concept, through the use of `boost::condition_variable_any`
+   (`boost::condition` is a typedef to `boost::condition_variable_any`, provided for
+   backwards compatibility). `boost::condition_variable` is provided as an
+   optimization, and will only work with `boost::unique_lock<boost::mutex>`
+   (`boost::mutex::scoped_lock`).
+    * Thread IDs are separated from boost::thread, so a thread can obtain it's
+   own ID (using `boost::this_thread::get_id()`), and IDs can be used as keys in
+   associative containers, as they have the full set of comparison operators.
+    * Timeouts are now implemented using the Boost DateTime library, through a
+   typedef `boost::system_time` for absolute timeouts, and with support for relative
+   timeouts in many cases. `boost::xtime` is supported for backwards compatibility
+   only.
+    * Locks are implemented as publicly accessible templates `boost::lock_guard`,
+   `boost::unique_lock`, `boost::shared_lock`, and `boost::upgrade_lock`, which are
+   templated on the type of the mutex. The Lockable concept has been extended to
+   include publicly available `lock()` and `unlock()` member functions, which are used
+   by the lock types.
+    * `boost::try_mutex` has been removed, and the functionality subsumed into
+   `boost::mutex`. `boost::try_mutex` is left as a typedef, but is no longer a separate
+   class.
+    * `boost::recursive_try_mutex` has been removed, and the functionality
+   subsumed into `boost::recursive_mutex`. `boost::recursive_try_mutex` is left as a
+   typedef, but is no longer a separate class.
+    * `boost::detail::thread::lock_ops` has been removed. Code that relies on the
+   `lock_ops` implementation detail will no longer work, as this has been removed, as
+   it is no longer necessary now that mutex types now have public `lock()` and
+   `unlock()` member functions.
+    * `scoped_lock` constructors with a second parameter of type bool are no
+   longer provided. With previous boost releases,
+      `boost::mutex::scoped_lock some_lock(some_mutex,false);`
+      could be used to create a lock object that was associated with a mutex,
+   but did not lock it on construction. This facility has now been replaced with
+   the constructor that takes a `boost::defer_lock_type` as the second parameter:
+      `boost::mutex::scoped_lock some_lock(some_mutex,boost::defer_lock);`
+    * The broken `boost::read_write_mutex` has been replaced with
+   `boost::shared_mutex`.
 * [phrase library..[@/libs/wave/index.html Wave]:] Standards conformant implementation of the 
   mandated C99/C++ preprocessor functionality packed behind an easy to use 
   iterator interface, from Hartmut Kaiser. Highlights:
Modified: website/public_html/beta/feed/news.rss
==============================================================================
--- website/public_html/beta/feed/news.rss	(original)
+++ website/public_html/beta/feed/news.rss	2008-03-16 05:48:43 EDT (Sun, 16 Mar 2008)
@@ -14,7 +14,7 @@
     &lt;h3&gt;&lt;span class="link"&gt;New Libraries&lt;/span&gt;&lt;/h3&gt;
     &lt;ul&gt;
       &lt;li&gt;
-        &lt;span class="library"&gt;&lt;a href="/libs/asio/index.html"&gt;ASIO&lt;/a&gt;:&lt;/span&gt; Portable networking,
+        &lt;span class="library"&gt;&lt;a href="/libs/asio/index.html"&gt;Asio&lt;/a&gt;:&lt;/span&gt; Portable networking,
         including sockets, timers, hostname resolution and socket iostreams, from
         Chris Kohlhoff.
       &lt;/li&gt;
@@ -100,6 +100,79 @@
         &lt;/ul&gt;
       &lt;/li&gt;
       &lt;li&gt;
+        &lt;span class="library"&gt;&lt;a href="/libs/thread/index.html"&gt;Thread&lt;/a&gt;:&lt;/span&gt;
+        &lt;ul&gt;
+          &lt;li&gt;
+            Instances of boost::thread and of the various lock types are now movable.
+          &lt;/li&gt;
+          &lt;li&gt;
+            Threads can be interrupted at interruption points.
+          &lt;/li&gt;
+          &lt;li&gt;
+            Condition variables can now be used with any type that implements the
+            Lockable concept, through the use of &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;condition_variable_any&lt;/span&gt;&lt;/code&gt;
+            (&lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;condition&lt;/span&gt;&lt;/code&gt; is a typedef to &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;condition_variable_any&lt;/span&gt;&lt;/code&gt;, provided for
+            backwards compatibility). &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;condition_variable&lt;/span&gt;&lt;/code&gt;
+            is provided as an optimization, and will only work with &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;unique_lock&lt;/span&gt;&lt;span class="special"&gt;&amp;lt;&lt;/span&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;mutex&lt;/span&gt;&lt;span class="special"&gt;&amp;gt;&lt;/span&gt;&lt;/code&gt;
+            (&lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;mutex&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;scoped_lock&lt;/span&gt;&lt;/code&gt;).
+          &lt;/li&gt;
+          &lt;li&gt;
+            Thread IDs are separated from boost::thread, so a thread can obtain it's
+            own ID (using &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;this_thread&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;get_id&lt;/span&gt;&lt;span class="special"&gt;()&lt;/span&gt;&lt;/code&gt;),
+            and IDs can be used as keys in associative containers, as they have the
+            full set of comparison operators.
+          &lt;/li&gt;
+          &lt;li&gt;
+            Timeouts are now implemented using the Boost DateTime library, through
+            a typedef &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;system_time&lt;/span&gt;&lt;/code&gt; for absolute timeouts,
+            and with support for relative timeouts in many cases. &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;xtime&lt;/span&gt;&lt;/code&gt;
+            is supported for backwards compatibility only.
+          &lt;/li&gt;
+          &lt;li&gt;
+            Locks are implemented as publicly accessible templates &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;lock_guard&lt;/span&gt;&lt;/code&gt;, &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;unique_lock&lt;/span&gt;&lt;/code&gt;,
+            &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;shared_lock&lt;/span&gt;&lt;/code&gt;, and &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;upgrade_lock&lt;/span&gt;&lt;/code&gt;,
+            which are templated on the type of the mutex. The Lockable concept has
+            been extended to include publicly available &lt;code&gt;&lt;span class="identifier"&gt;lock&lt;/span&gt;&lt;span class="special"&gt;()&lt;/span&gt;&lt;/code&gt; and &lt;code&gt;&lt;span class="identifier"&gt;unlock&lt;/span&gt;&lt;span class="special"&gt;()&lt;/span&gt;&lt;/code&gt; member functions, which are used by
+            the lock types.
+          &lt;/li&gt;
+          &lt;li&gt;
+            &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;try_mutex&lt;/span&gt;&lt;/code&gt; has been removed, and the
+            functionality subsumed into &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;mutex&lt;/span&gt;&lt;/code&gt;.
+            &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;try_mutex&lt;/span&gt;&lt;/code&gt; is left as a typedef, but
+            is no longer a separate class.
+          &lt;/li&gt;
+          &lt;li&gt;
+            &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;recursive_try_mutex&lt;/span&gt;&lt;/code&gt; has been removed,
+            and the functionality subsumed into &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;recursive_mutex&lt;/span&gt;&lt;/code&gt;.
+            &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;recursive_try_mutex&lt;/span&gt;&lt;/code&gt; is left as a typedef,
+            but is no longer a separate class.
+          &lt;/li&gt;
+          &lt;li&gt;
+            &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;detail&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;thread&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;lock_ops&lt;/span&gt;&lt;/code&gt; has been removed. Code that
+            relies on the &lt;code&gt;&lt;span class="identifier"&gt;lock_ops&lt;/span&gt;&lt;/code&gt;
+            implementation detail will no longer work, as this has been removed,
+            as it is no longer necessary now that mutex types now have public &lt;code&gt;&lt;span class="identifier"&gt;lock&lt;/span&gt;&lt;span class="special"&gt;()&lt;/span&gt;&lt;/code&gt;
+            and &lt;code&gt;&lt;span class="identifier"&gt;unlock&lt;/span&gt;&lt;span class="special"&gt;()&lt;/span&gt;&lt;/code&gt;
+            member functions.
+          &lt;/li&gt;
+          &lt;li&gt;
+            &lt;code&gt;&lt;span class="identifier"&gt;scoped_lock&lt;/span&gt;&lt;/code&gt; constructors
+            with a second parameter of type bool are no longer provided. With previous
+            boost releases, &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;mutex&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;scoped_lock&lt;/span&gt;
+            &lt;span class="identifier"&gt;some_lock&lt;/span&gt;&lt;span class="special"&gt;(&lt;/span&gt;&lt;span class="identifier"&gt;some_mutex&lt;/span&gt;&lt;span class="special"&gt;,&lt;/span&gt;&lt;span class="keyword"&gt;false&lt;/span&gt;&lt;span class="special"&gt;);&lt;/span&gt;&lt;/code&gt;
+            could be used to create a lock object that was associated with a mutex,
+            but did not lock it on construction. This facility has now been replaced
+            with the constructor that takes a &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;defer_lock_type&lt;/span&gt;&lt;/code&gt;
+            as the second parameter: &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;mutex&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;scoped_lock&lt;/span&gt;
+            &lt;span class="identifier"&gt;some_lock&lt;/span&gt;&lt;span class="special"&gt;(&lt;/span&gt;&lt;span class="identifier"&gt;some_mutex&lt;/span&gt;&lt;span class="special"&gt;,&lt;/span&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;defer_lock&lt;/span&gt;&lt;span class="special"&gt;);&lt;/span&gt;&lt;/code&gt;
+          &lt;/li&gt;
+          &lt;li&gt;
+            The broken &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;read_write_mutex&lt;/span&gt;&lt;/code&gt; has been replaced
+            with &lt;code&gt;&lt;span class="identifier"&gt;boost&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;shared_mutex&lt;/span&gt;&lt;/code&gt;.
+          &lt;/li&gt;
+        &lt;/ul&gt;
+      &lt;/li&gt;
+      &lt;li&gt;
         &lt;span class="library"&gt;&lt;a href="/libs/wave/index.html"&gt;Wave&lt;/a&gt;:&lt;/span&gt; Standards conformant
         implementation of the mandated C99/C++ preprocessor functionality packed
         behind an easy to use iterator interface, from Hartmut Kaiser. Highlights:
@@ -159,6 +232,23 @@
           &lt;/li&gt;
         &lt;/ul&gt;
       &lt;/li&gt;
+      &lt;li&gt;
+        &lt;span class="library"&gt;&lt;a href="/libs/functional/hash/index.html"&gt;Hash&lt;/a&gt;:&lt;/span&gt;
+  A TR1 hash
+        function object, from Daniel James. Highlights:
+        &lt;ul&gt;
+          &lt;li&gt;
+            Support for &lt;code&gt;&lt;span class="keyword"&gt;long&lt;/span&gt; &lt;span class="keyword"&gt;long&lt;/span&gt;&lt;/code&gt;,
+            &lt;code&gt;&lt;span class="identifier"&gt;std&lt;/span&gt;&lt;span class="special"&gt;::&lt;/span&gt;&lt;span class="identifier"&gt;complex&lt;/span&gt;&lt;/code&gt;.
+          &lt;/li&gt;
+          &lt;li&gt;
+            Improved the algorithm for hashing floating point numbers.
+          &lt;/li&gt;
+          &lt;li&gt;
+            A few bug and warning fixes.
+          &lt;/li&gt;
+        &lt;/ul&gt;
+      &lt;/li&gt;
     &lt;/ul&gt;
   &lt;/div&gt;
   &lt;div id="version_1_35_0.supported_compilers"&gt;