Imported Upstream version 1.61.0

Change-Id: I96a1f878d1e6164f01e9aadd5147f38fca448d90
Signed-off-by: DongHun Kwak <dh0128.kwak@samsung.com>

22 files changed, 2697 insertions, 108 deletions

diff --git a/libs/align/doc/align.qbk b/libs/align/doc/align.qbk
index de3a0d7b0e..0b9e70014b 100644
--- a/libs/align/doc/align.qbk
+++ b/libs/align/doc/align.qbk
@@ -31,6 +31,9 @@ verify pointer value alignment.
   [ [`align`]
     [Pointer alignment function]
   ]
+  [ [`align_up`, `align_down`]
+    [Pointer and integral alignment functions]
+  ]
   [ [`aligned_alloc`, `aligned_free`]
     [Aligned allocation and deallocation functions]
   ]
@@ -50,7 +53,7 @@ verify pointer value alignment.
     [Macro for static pointer alignment hint]
   ]
   [ [`is_aligned`]
-    [Pointer alignment verification function]
+    [Pointer and integral alignment checking]
   ]
 ]
 
@@ -546,6 +549,84 @@ void* align(std::size_t alignment, std::size_t size, void*& ptr,
 
 [endsect]
 
+[section:align_down align_down]
+
+The directional alignment functions can be used with pointers or
+integral values to align down. This functionality is not yet provided by
+the C++ standard.
+
+[heading:synopsis Header <boost/align/align_down.hpp>]
+
+``
+namespace boost {
+  namespace alignment {
+    constexpr std::size_t align_down(std::size_t value, std::size_t
+      alignment) noexcept;
+
+    void* align_down(void* ptr, std::size_t alignment) noexcept;
+  }
+}
+``
+
+[heading:align_down Function align_down]
+
+``
+void* align_down(void* ptr, std::size_t alignment) noexcept;
+``
+
+[:
+  [*Requires:]
+  [itemized_list
+    [`ptr` shall point to contiguous storage with sufficient space
+      for alignment]
+    [`alignment` shall be a power of two]
+  ]
+
+  [*Returns:] A pointer value at or before `ptr` that is at least
+  `alignment` bytes aligned.
+]
+
+[endsect]
+
+[section:align_up align_up]
+
+The directional alignment functions can be used with pointers or
+integral values to align up. This functionality is not yet provided by
+the C++ standard.
+
+[heading:synopsis Header <boost/align/align_up.hpp>]
+
+``
+namespace boost {
+  namespace alignment {
+    constexpr std::size_t align_up(std::size_t value, std::size_t
+      alignment) noexcept;
+
+    void* align_up(void* ptr, std::size_t alignment) noexcept;
+  }
+}
+``
+
+[heading:align_up Function align_up]
+
+``
+void* align_up(void* ptr, std::size_t alignment) noexcept;
+``
+
+[:
+  [*Requires:]
+  [itemized_list
+    [`ptr` shall point to contiguous storage with sufficient space
+      for alignment]
+    [`alignment` shall be a power of two]
+  ]
+
+  [*Returns:] A pointer value at or after `ptr` that is at least
+  `alignment` bytes aligned.
+]
+
+[endsect]
+
 [section:aligned_alloc aligned_alloc and aligned_free]
 
 The aligned allocation function is a replacement for
@@ -1087,6 +1168,9 @@ namespace boost {
   namespace alignment {
     template<class T>
     struct alignment_of;
+
+    template<class T>
+    constexpr std::size_t alignment_of_v = alignment_of<T>::value;
   }
 }
 ``
@@ -1095,9 +1179,7 @@ namespace boost {
 
 ``
 template<class T>
-struct alignment_of
-    : integral_constant<std::size_t, alignof(T)> {
-};
+struct alignment_of;
 ``
 
 [:
@@ -1155,7 +1237,10 @@ is not yet provided by the C++ standard.
 ``
 namespace boost {
   namespace alignment {
-    bool is_aligned(std::size_t alignment, const void* ptr) noexcept;
+    constexpr bool is_aligned(std::size_t value, std::size_t
+      alignment) noexcept;
+
+    bool is_aligned(const void* ptr, std::size_t alignment) noexcept;
   }
 }
 ``
@@ -1163,7 +1248,7 @@ namespace boost {
 [heading:is_aligned Function is_aligned]
 
 ``
-bool is_aligned(std::size_t alignment, const void* ptr) noexcept;
+bool is_aligned(const void* ptr, std::size_t alignment) noexcept;
 ``
 
 [:
@@ -1321,16 +1406,29 @@ examples, tests, or documentation.
 * Michael Spencer
 * Paul A. Bristow
 
-[heading Review Manager]
-
 Thank you to Ahmed Charles who served as review manager for the formal
 review of the library.
 
+[heading Contributions]
+
+Thank you to Joel Falcou and Charly Chevalier for both your contribution
+and your patience.
+
 [endsect]
 
 [section History]
 
-[heading Version 1.0]
+[heading Boost 1.61]
+
+* Added functions for aligning up and aligning down of pointer and
+  integral values.
+
+[heading Boost 1.59]
+
+* Joel Falcou and Charly Chevalier together contributed the alignment
+  hint macros.
+
+[heading Boost 1.56]
 
 * Glen Fernandes implemented the Boost.Align library.
 
diff --git a/libs/align/doc/html/align/acknowledgments.html b/libs/align/doc/html/align/acknowledgments.html
new file mode 100644
index 0000000000..272e34b355
--- /dev/null
+++ b/libs/align/doc/html/align/acknowledgments.html
@@ -0,0 +1,93 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Acknowledgments</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="compatibility.html" title="Compatibility">
+<link rel="next" href="history.html" title="History">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="compatibility.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.acknowledgments"></a><a class="link" href="acknowledgments.html" title="Acknowledgments">Acknowledgments</a>
+</h2></div></div></div>
+<p>
+      Glen Fernandes authored the library and contributed it to the Boost C++ library
+      collection.
+    </p>
+<h4>
+<a name="align.acknowledgments.h0"></a>
+      <span><a name="align.acknowledgments.library_reviews"></a></span><a class="link" href="acknowledgments.html#align.acknowledgments.library_reviews">Library
+      Reviews</a>
+    </h4>
+<p>
+      Thank you to the following developers who reviewed the design, code, examples,
+      tests, or documentation.
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Peter Dimov
+        </li>
+<li class="listitem">
+          Andrey Semashev
+        </li>
+<li class="listitem">
+          Bjorn Reese
+        </li>
+<li class="listitem">
+          Steven Watanabe
+        </li>
+<li class="listitem">
+          Antony Polukhin
+        </li>
+<li class="listitem">
+          Lars Viklund
+        </li>
+<li class="listitem">
+          Michael Spencer
+        </li>
+<li class="listitem">
+          Paul A. Bristow
+        </li>
+</ul></div>
+<p>
+      Thank you to Ahmed Charles who served as review manager for the formal review
+      of the library.
+    </p>
+<h4>
+<a name="align.acknowledgments.h1"></a>
+      <span><a name="align.acknowledgments.contributions"></a></span><a class="link" href="acknowledgments.html#align.acknowledgments.contributions">Contributions</a>
+    </h4>
+<p>
+      Thank you to Joel Falcou and Charly Chevalier for both your contribution and
+      your patience.
+    </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="compatibility.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/align/compatibility.html b/libs/align/doc/html/align/compatibility.html
new file mode 100644
index 0000000000..952815dd6b
--- /dev/null
+++ b/libs/align/doc/html/align/compatibility.html
@@ -0,0 +1,222 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Compatibility</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="vocabulary.html" title="Vocabulary">
+<link rel="next" href="acknowledgments.html" title="Acknowledgments">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="vocabulary.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgments.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.compatibility"></a><a class="link" href="compatibility.html" title="Compatibility">Compatibility</a>
+</h2></div></div></div>
+<p>
+      Boost.Align has been tested with GCC, Clang, Visual C++, and Intel C++, on
+      Linux, Windows, and OS X. It supports any conforming C++11 or C++03 compilers.
+    </p>
+<div class="table">
+<a name="align.compatibility.compilers_tested"></a><p class="title"><b>Table&#160;1.3.&#160;Compilers Tested</b></p>
+<div class="table-contents"><table class="table" summary="Compilers Tested">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+                Compiler
+              </p>
+            </th>
+<th>
+              <p>
+                Version
+              </p>
+            </th>
+<th>
+              <p>
+                Library
+              </p>
+            </th>
+<th>
+              <p>
+                Platform
+              </p>
+            </th>
+<th>
+              <p>
+                Hardware
+              </p>
+            </th>
+<th>
+              <p>
+                Standard
+              </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                clang
+              </p>
+            </td>
+<td>
+              <p>
+                3.0 - 3.6
+              </p>
+            </td>
+<td>
+              <p>
+                libstdc++, libc++
+              </p>
+            </td>
+<td>
+              <p>
+                linux, darwin
+              </p>
+            </td>
+<td>
+              <p>
+                x86, x64
+              </p>
+            </td>
+<td>
+              <p>
+                c++11, c++03
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                gcc
+              </p>
+            </td>
+<td>
+              <p>
+                4.4 - 5.1
+              </p>
+            </td>
+<td>
+              <p>
+                libstdc++
+              </p>
+            </td>
+<td>
+              <p>
+                linux, windows
+              </p>
+            </td>
+<td>
+              <p>
+                x86, x64, arm
+              </p>
+            </td>
+<td>
+              <p>
+                c++11, c++03
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                intel
+              </p>
+            </td>
+<td>
+              <p>
+                11.1 - 15.0
+              </p>
+            </td>
+<td>
+              <p>
+                libstdc++
+              </p>
+            </td>
+<td>
+              <p>
+                linux
+              </p>
+            </td>
+<td>
+              <p>
+                x86, x64
+              </p>
+            </td>
+<td>
+              <p>
+                c++11, c++03
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                msvc
+              </p>
+            </td>
+<td>
+              <p>
+                8.0 - 14.0
+              </p>
+            </td>
+<td>
+              <p>
+                dinkumware
+              </p>
+            </td>
+<td>
+              <p>
+                windows
+              </p>
+            </td>
+<td>
+              <p>
+                x86, x64
+              </p>
+            </td>
+<td>
+              <p>
+                default
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="vocabulary.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgments.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/align/examples.html b/libs/align/doc/html/align/examples.html
new file mode 100644
index 0000000000..4ba5d9ac13
--- /dev/null
+++ b/libs/align/doc/html/align/examples.html
@@ -0,0 +1,141 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Examples</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="tutorial.html" title="Tutorial">
+<link rel="next" href="reference.html" title="Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="examples.html#align.examples.aligned_ptr">aligned_ptr and make_aligned</a></span></dt>
+<dt><span class="section"><a href="examples.html#align.examples.aligned_vector">aligned_vector</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.examples.aligned_ptr"></a><a class="link" href="examples.html#align.examples.aligned_ptr" title="aligned_ptr and make_aligned">aligned_ptr and make_aligned</a>
+</h3></div></div></div>
+<p>
+        This example presents an alternative to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span></code>
+        for objects allocated with the aligned allocation function. It is defined
+        simply by providing an alias template which uses <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span></code>
+        with our aligned deleter in place of the default <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">default_delete</span></code>
+        deleter. It also presents an alternative to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">make_unique</span></code>
+        for the creation of these aligned unique pointer objects. It is implemented
+        using our aligned allocation function.
+      </p>
+<h5>
+<a name="align.examples.aligned_ptr.h0"></a>
+        <span><a name="align.examples.aligned_ptr.implementation"></a></span><a class="link" href="examples.html#align.examples.aligned_ptr.implementation">Implementation</a>
+      </h5>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_alloc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_delete</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">alignment_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">memory</span><span class="special">&gt;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">aligned_ptr</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
+    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_delete</span><span class="special">&gt;;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">inline</span> <span class="identifier">aligned_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">make_aligned</span><span class="special">(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="keyword">auto</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span>
+        <span class="identifier">alignment</span><span class="special">::</span><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">));</span>
+    <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">p</span><span class="special">)</span> <span class="special">{</span>
+        <span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span><span class="special">();</span>
+    <span class="special">}</span>
+    <span class="keyword">try</span> <span class="special">{</span>
+        <span class="keyword">auto</span> <span class="identifier">q</span> <span class="special">=</span> <span class="special">::</span><span class="keyword">new</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="identifier">T</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">)...);</span>
+        <span class="keyword">return</span> <span class="identifier">aligned_ptr</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">q</span><span class="special">);</span>
+    <span class="special">}</span> <span class="keyword">catch</span> <span class="special">(...)</span> <span class="special">{</span>
+        <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_free</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span>
+        <span class="keyword">throw</span><span class="special">;</span>
+    <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.examples.aligned_ptr.h1"></a>
+        <span><a name="align.examples.aligned_ptr.usage"></a></span><a class="link" href="examples.html#align.examples.aligned_ptr.usage">Usage</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="identifier">type</span> <span class="special">{</span>
+    <span class="keyword">float</span> <span class="identifier">data</span><span class="special">[</span><span class="number">4</span><span class="special">];</span>
+<span class="special">};</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">auto</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">make_aligned</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">&gt;();</span>
+    <span class="identifier">p</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.examples.aligned_vector"></a><a class="link" href="examples.html#align.examples.aligned_vector" title="aligned_vector">aligned_vector</a>
+</h3></div></div></div>
+<p>
+        This example presents an alternative to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>
+        that can be used with over-aligned types, and allows specifying a minimum
+        alignment. It is defined simply by providing an alias template which uses
+        <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code> with our aligned allocator.
+      </p>
+<h5>
+<a name="align.examples.aligned_vector.h0"></a>
+        <span><a name="align.examples.aligned_vector.implementation"></a></span><a class="link" href="examples.html#align.examples.aligned_vector.implementation">Implementation</a>
+      </h5>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_allocator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">aligned_vector</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
+    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">&gt;</span> <span class="special">&gt;;</span>
+</pre>
+<h5>
+<a name="align.examples.aligned_vector.h1"></a>
+        <span><a name="align.examples.aligned_vector.usage"></a></span><a class="link" href="examples.html#align.examples.aligned_vector.usage">Usage</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">enum</span>
+    <span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="special">{</span>
+    <span class="identifier">cache_line</span> <span class="special">=</span> <span class="number">64</span>
+<span class="special">};</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="identifier">aligned_vector</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">cache_line</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
+    <span class="identifier">v</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">();</span>
+<span class="special">}</span>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/align/history.html b/libs/align/doc/html/align/history.html
new file mode 100644
index 0000000000..8650aab5d5
--- /dev/null
+++ b/libs/align/doc/html/align/history.html
@@ -0,0 +1,67 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>History</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="acknowledgments.html" title="Acknowledgments">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="acknowledgments.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.history"></a><a class="link" href="history.html" title="History">History</a>
+</h2></div></div></div>
+<h4>
+<a name="align.history.h0"></a>
+      <span><a name="align.history.boost_1_61"></a></span><a class="link" href="history.html#align.history.boost_1_61">Boost
+      1.61</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+          Added functions for aligning up and aligning down of pointer and integral
+          values.
+        </li></ul></div>
+<h4>
+<a name="align.history.h1"></a>
+      <span><a name="align.history.boost_1_59"></a></span><a class="link" href="history.html#align.history.boost_1_59">Boost
+      1.59</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+          Joel Falcou and Charly Chevalier together contributed the alignment hint
+          macros.
+        </li></ul></div>
+<h4>
+<a name="align.history.h2"></a>
+      <span><a name="align.history.boost_1_56"></a></span><a class="link" href="history.html#align.history.boost_1_56">Boost
+      1.56</a>
+    </h4>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+          Glen Fernandes implemented the Boost.Align library.
+        </li></ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="acknowledgments.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/align/rationale.html b/libs/align/doc/html/align/rationale.html
new file mode 100644
index 0000000000..9b799e5957
--- /dev/null
+++ b/libs/align/doc/html/align/rationale.html
@@ -0,0 +1,190 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Rationale</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="next" href="tutorial.html" title="Tutorial">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.rationale"></a><a class="link" href="rationale.html" title="Rationale">Rationale</a>
+</h2></div></div></div>
+<h4>
+<a name="align.rationale.h0"></a>
+      <span><a name="align.rationale.dynamic_allocation"></a></span><a class="link" href="rationale.html#align.rationale.dynamic_allocation">Dynamic
+      allocation</a>
+    </h4>
+<p>
+      C++11 added the ability to specify increased alignment (over-alignment) for
+      class types. Unfortunately, <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span> <span class="keyword">new</span></code>
+      allocation functions, <code class="computeroutput"><span class="keyword">new</span></code> expressions,
+      and the default allocator, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span></code>,
+      do not support dynamic memory allocation of over-aligned data. This library
+      provides allocation functions, allocators, allocator adaptors, and deleters,
+      that are alignment aware.
+    </p>
+<div class="table">
+<a name="align.rationale.boost_align_solutions"></a><p class="title"><b>Table&#160;1.2.&#160;Boost.Align solutions</b></p>
+<div class="table-contents"><table class="table" summary="Boost.Align solutions">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+                Problem
+              </p>
+            </th>
+<th>
+              <p>
+                Solution
+              </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span>
+                <span class="keyword">new</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">no_throw_t</span><span class="special">&amp;)</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span>
+                <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">)</span></code>
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span>
+                <span class="keyword">delete</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_free</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">Allocator</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;</span></code>
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">default_delete</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_delete</span></code>
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><h4>
+<a name="align.rationale.h1"></a>
+      <span><a name="align.rationale.alignment_functions"></a></span><a class="link" href="rationale.html#align.rationale.alignment_functions">Alignment
+      functions</a>
+    </h4>
+<p>
+      C++11 provided <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">align</span></code> in the standard library to align a
+      pointer value. Unfortunately some C++ standard library implementations do not
+      support it yet (libstdc++ as far as gcc 4.8.0) and other standard library implementations
+      implement it incorrectly (dinkumware in msvc 11.0). This library provides it
+      for those implementations and also for C++03 compilers where it is equally
+      useful.
+    </p>
+<h4>
+<a name="align.rationale.h2"></a>
+      <span><a name="align.rationale.alignment_traits"></a></span><a class="link" href="rationale.html#align.rationale.alignment_traits">Alignment
+      traits</a>
+    </h4>
+<p>
+      C++11 provided the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">alignment_of</span></code> trait in the standard library
+      to query the alignment requirement of a type. Unfortunately some C++ standard
+      library vendors do not implement it in an entirely standard conforming manner,
+      such as for array types (libc++ as far as clang 3.4). Other vendor implementations
+      report incorrect values for certain types, such as pointer to members (msvc
+      14.0). This library provides it for those implementations and also for C++03
+      compilers where it is equally useful.
+    </p>
+<h4>
+<a name="align.rationale.h3"></a>
+      <span><a name="align.rationale.alignment_hints"></a></span><a class="link" href="rationale.html#align.rationale.alignment_hints">Alignment
+      hints</a>
+    </h4>
+<p>
+      Allocating aligned memory is sometimes not enough to ensure that optimal code
+      is generated. Developers use specific compiler intrinsics to notify the compiler
+      of a given alignment property of a memory block. This library provides a macro
+      to abstract that functionality for compilers with the appropriate intrinsics.
+    </p>
+<h4>
+<a name="align.rationale.h4"></a>
+      <span><a name="align.rationale.alignment_testing"></a></span><a class="link" href="rationale.html#align.rationale.alignment_testing">Alignment
+      testing</a>
+    </h4>
+<p>
+      This library provides a function to test the alignment of a pointer value.
+      It is generally useful in assertions to validate that memory is correctly aligned.
+    </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/align/reference.html b/libs/align/doc/html/align/reference.html
new file mode 100644
index 0000000000..050c7d04c9
--- /dev/null
+++ b/libs/align/doc/html/align/reference.html
@@ -0,0 +1,924 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Reference</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="examples.html" title="Examples">
+<link rel="next" href="vocabulary.html" title="Vocabulary">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="examples.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="vocabulary.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.reference"></a><a class="link" href="reference.html" title="Reference">Reference</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="reference.html#align.reference.align">align</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.align_down">align_down</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.align_up">align_up</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.aligned_alloc">aligned_alloc and aligned_free</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.aligned_allocator">aligned_allocator</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.aligned_allocator_adaptor">aligned_allocator_adaptor</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.aligned_delete">aligned_delete</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.alignment_of">alignment_of</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.assume_aligned">assume_aligned</a></span></dt>
+<dt><span class="section"><a href="reference.html#align.reference.is_aligned">is_aligned</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.align"></a><a class="link" href="reference.html#align.reference.align" title="align">align</a>
+</h3></div></div></div>
+<p>
+        The alignment function is used to obtain a pointer to the first address within
+        the specified buffer that is a multiple of the specified alignment value.
+        This function exists in the C++11 standard library but is provided in this
+        library for those C++11 and C++03 library implementations which do not yet
+        support it.
+      </p>
+<h5>
+<a name="align.reference.align.h0"></a>
+        <span><a name="align.reference.align.synopsis"></a></span><a class="link" href="reference.html#align.reference.align.synopsis">Header
+        &lt;boost/align/align.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">void</span><span class="special">*</span> <span class="identifier">align</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*&amp;</span> <span class="identifier">ptr</span><span class="special">,</span>
+      <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">&amp;</span> <span class="identifier">space</span><span class="special">);</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.align.h1"></a>
+        <span><a name="align.reference.align.align"></a></span><a class="link" href="reference.html#align.reference.align.align">Function
+        align</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">void</span><span class="special">*</span> <span class="identifier">align</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*&amp;</span> <span class="identifier">ptr</span><span class="special">,</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">&amp;</span> <span class="identifier">space</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Effects:</strong></span> If it is possible to fit <code class="computeroutput"><span class="identifier">size</span></code> bytes of storage aligned by <code class="computeroutput"><span class="identifier">alignment</span></code> into the buffer pointed to
+          by <code class="computeroutput"><span class="identifier">ptr</span></code> with length <code class="computeroutput"><span class="identifier">space</span></code>, the function updates <code class="computeroutput"><span class="identifier">ptr</span></code> to point to the first possible address
+          of such storage and decreases <code class="computeroutput"><span class="identifier">space</span></code>
+          by the number of bytes used for alignment. Otherwise, the function does
+          nothing.
+        </p>
+<p>
+          <span class="bold"><strong>Requires:</strong></span>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">alignment</span></code> shall be
+              a fundamental alignment value or an extended alignment value, and shall
+              be a power of two
+            </li>
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">ptr</span></code> shall point to
+              contiguous storage of at least <code class="computeroutput"><span class="identifier">space</span></code>
+              bytes
+            </li>
+</ul></div>
+<p>
+          <span class="bold"><strong>Returns:</strong></span> A null pointer if the requested
+          aligned buffer would not fit into the available space, otherwise the adjusted
+          value of <code class="computeroutput"><span class="identifier">ptr</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Note:</strong></span> The function updates its <code class="computeroutput"><span class="identifier">ptr</span></code> and <code class="computeroutput"><span class="identifier">space</span></code>
+          arguments so that it can be called repeatedly with possibly different
+          <code class="computeroutput"><span class="identifier">alignment</span></code> and <code class="computeroutput"><span class="identifier">size</span></code> arguments for the same buffer.
+        </p>
+</blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.align_down"></a><a class="link" href="reference.html#align.reference.align_down" title="align_down">align_down</a>
+</h3></div></div></div>
+<p>
+        The directional alignment functions can be used with pointers or integral
+        values to align down. This functionality is not yet provided by the C++ standard.
+      </p>
+<h5>
+<a name="align.reference.align_down.h0"></a>
+        <span><a name="align.reference.align_down.synopsis"></a></span><a class="link" href="reference.html#align.reference.align_down.synopsis">Header
+        &lt;boost/align/align_down.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">constexpr</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">align_down</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span>
+      <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">void</span><span class="special">*</span> <span class="identifier">align_down</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.align_down.h1"></a>
+        <span><a name="align.reference.align_down.align_down"></a></span><a class="link" href="reference.html#align.reference.align_down.align_down">Function
+        align_down</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">void</span><span class="special">*</span> <span class="identifier">align_down</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">ptr</span></code> shall point to
+              contiguous storage with sufficient space for alignment
+            </li>
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">alignment</span></code> shall be
+              a power of two
+            </li>
+</ul></div>
+<p>
+          <span class="bold"><strong>Returns:</strong></span> A pointer value at or before
+          <code class="computeroutput"><span class="identifier">ptr</span></code> that is at least <code class="computeroutput"><span class="identifier">alignment</span></code> bytes aligned.
+        </p>
+</blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.align_up"></a><a class="link" href="reference.html#align.reference.align_up" title="align_up">align_up</a>
+</h3></div></div></div>
+<p>
+        The directional alignment functions can be used with pointers or integral
+        values to align up. This functionality is not yet provided by the C++ standard.
+      </p>
+<h5>
+<a name="align.reference.align_up.h0"></a>
+        <span><a name="align.reference.align_up.synopsis"></a></span><a class="link" href="reference.html#align.reference.align_up.synopsis">Header
+        &lt;boost/align/align_up.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">constexpr</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">align_up</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span>
+      <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">void</span><span class="special">*</span> <span class="identifier">align_up</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.align_up.h1"></a>
+        <span><a name="align.reference.align_up.align_up"></a></span><a class="link" href="reference.html#align.reference.align_up.align_up">Function
+        align_up</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">void</span><span class="special">*</span> <span class="identifier">align_up</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">ptr</span></code> shall point to
+              contiguous storage with sufficient space for alignment
+            </li>
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">alignment</span></code> shall be
+              a power of two
+            </li>
+</ul></div>
+<p>
+          <span class="bold"><strong>Returns:</strong></span> A pointer value at or after
+          <code class="computeroutput"><span class="identifier">ptr</span></code> that is at least <code class="computeroutput"><span class="identifier">alignment</span></code> bytes aligned.
+        </p>
+</blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.aligned_alloc"></a><a class="link" href="reference.html#align.reference.aligned_alloc" title="aligned_alloc and aligned_free">aligned_alloc and aligned_free</a>
+</h3></div></div></div>
+<p>
+        The aligned allocation function is a replacement for <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span> <span class="keyword">new</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">no_throw_t</span><span class="special">&amp;)</span></code> that allows requesting aligned memory.
+        The deallocation function replaces the corresponding <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span> <span class="keyword">delete</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
+        function. This functionality is not yet provided by the C++ standard.
+      </p>
+<h5>
+<a name="align.reference.aligned_alloc.h0"></a>
+        <span><a name="align.reference.aligned_alloc.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_alloc.synopsis">Header
+        &lt;boost/align/aligned_alloc.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">void</span><span class="special">*</span> <span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">);</span>
+
+    <span class="keyword">void</span> <span class="identifier">aligned_free</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.aligned_alloc.h1"></a>
+        <span><a name="align.reference.aligned_alloc.aligned_alloc"></a></span><a class="link" href="reference.html#align.reference.aligned_alloc.aligned_alloc">Function
+        aligned_alloc</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">void</span><span class="special">*</span> <span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Effects:</strong></span> Allocates space for an object
+          whose alignment is specified by <code class="computeroutput"><span class="identifier">alignment</span></code>,
+          whose size is specified by <code class="computeroutput"><span class="identifier">size</span></code>,
+          and whose value is indeterminate. The value of <code class="computeroutput"><span class="identifier">alignment</span></code>
+          shall be a power of two.
+        </p>
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">alignment</span></code>
+          shall be a power of two.
+        </p>
+<p>
+          <span class="bold"><strong>Returns:</strong></span> A null pointer or a pointer to
+          the allocated space.
+        </p>
+<p>
+          <span class="bold"><strong>Note:</strong></span> On certain platforms, the alignment
+          may be rounded up to <code class="computeroutput"><span class="keyword">alignof</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
+          and the space allocated may be slightly larger than <code class="computeroutput"><span class="identifier">size</span></code>
+          bytes, by an additional <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>
+          and <code class="computeroutput"><span class="identifier">alignment</span> <span class="special">-</span>
+          <span class="number">1</span></code> bytes.
+        </p>
+</blockquote></div>
+<h5>
+<a name="align.reference.aligned_alloc.h2"></a>
+        <span><a name="align.reference.aligned_alloc.aligned_free"></a></span><a class="link" href="reference.html#align.reference.aligned_alloc.aligned_free">Function
+        aligned_free</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">aligned_free</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Effects:</strong></span> Causes the space pointed to by
+          <code class="computeroutput"><span class="identifier">ptr</span></code> to be deallocated,
+          that is, made available for further allocation. If <code class="computeroutput"><span class="identifier">ptr</span></code>
+          is a null pointer, no action occurs. Otherwise, if the argument does not
+          match a pointer earlier returned by the <code class="computeroutput"><span class="identifier">aligned_alloc</span></code>
+          function, or if the space has been deallocated by a call to <code class="computeroutput"><span class="identifier">aligned_free</span></code>, the behavior is undefined.
+        </p>
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span></code>
+          is a null pointer or a pointer earlier returned by the <code class="computeroutput"><span class="identifier">aligned_alloc</span></code>
+          function that has not been deallocated by a call to <code class="computeroutput"><span class="identifier">aligned_free</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Returns:</strong></span> The <code class="computeroutput"><span class="identifier">aligned_free</span></code>
+          function returns no value.
+        </p>
+</blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.aligned_allocator"></a><a class="link" href="reference.html#align.reference.aligned_allocator" title="aligned_allocator">aligned_allocator</a>
+</h3></div></div></div>
+<p>
+        The aligned allocator is a replacement for the default allocator, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span></code>,
+        that supports value types which are over-aligned. It also allows specifying
+        a minimum alignment value used for all allocations, via the optional template
+        parameter. An alignment aware allocator is not yet provided by the C++ standard.
+      </p>
+<div class="tip"><table border="0" summary="Tip">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
+<th align="left">Tip</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          Using the aligned allocator with a minimum alignment value is generally
+          only suitable with containers that are not node-based such as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>. With node-based containers, such
+          as list, the node object would have the minimum alignment instead of the
+          value type object.
+        </p></td></tr>
+</table></div>
+<h5>
+<a name="align.reference.aligned_allocator.h0"></a>
+        <span><a name="align.reference.aligned_allocator.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.synopsis">Header
+        &lt;boost/align/aligned_allocator.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">&gt;</span>
+    <span class="keyword">class</span> <span class="identifier">aligned_allocator</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">&gt;</span>
+    <span class="keyword">class</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">&gt;;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.aligned_allocator.h1"></a>
+        <span><a name="align.reference.aligned_allocator.aligned_allocator"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.aligned_allocator">Class
+        template aligned_allocator</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">aligned_allocator</span> <span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">const_pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">void_pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">const_void_pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size_type</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">reference</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">const_reference</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
+        <span class="keyword">typedef</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">&gt;</span> <span class="identifier">other</span><span class="special">;</span>
+    <span class="special">};</span>
+
+    <span class="identifier">aligned_allocator</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+    <span class="identifier">aligned_allocator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">&gt;&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="identifier">pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="identifier">const_pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">const_reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
+
+    <span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">);</span>
+
+    <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+    <span class="keyword">void</span> <span class="identifier">construct</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">);</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+    <span class="keyword">void</span> <span class="identifier">destroy</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">&gt;</span> <span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">value_type</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">const_pointer</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
+        <span class="keyword">typedef</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">&gt;</span> <span class="identifier">other</span><span class="special">;</span>
+    <span class="special">};</span>
+<span class="special">};</span>
+</pre>
+<h5>
+<a name="align.reference.aligned_allocator.h2"></a>
+        <span><a name="align.reference.aligned_allocator.members"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.members">Members</a>
+      </h5>
+<p>
+        Except for the destructor, member functions of the aligned allocator shall
+        not introduce data races as a result of concurrent calls to those member
+        functions from different threads. Calls to these functions that allocate
+        or deallocate a particular unit of storage shall occur in a single total
+        order, and each such deallocation call shall happen before the next allocation
+        (if any) in this order.
+      </p>
+<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> The actual address of the object
+          referenced by <code class="computeroutput"><span class="identifier">value</span></code>, even
+          in the presence of an overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>.
+        </p></blockquote></div>
+<pre class="programlisting"><span class="identifier">const_pointer</span> <span class="identifier">address</span><span class="special">(</span><span class="identifier">const_reference</span> <span class="identifier">value</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> The actual address of the object
+          referenced by <code class="computeroutput"><span class="identifier">value</span></code>, even
+          in the presence of an overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>.
+        </p></blockquote></div>
+<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Returns:</strong></span> A pointer to the initial element
+          of an array of storage of size <code class="computeroutput"><span class="identifier">n</span>
+          <span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code>,
+          aligned on the maximum of the minimum alignment specified and the alignment
+          of objects of type <code class="computeroutput"><span class="identifier">T</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Remark:</strong></span> The storage is obtained by calling
+          <code class="computeroutput"><span class="identifier">aligned_alloc</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">)</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Throws:</strong></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code>
+          if the storage cannot be obtained.
+        </p>
+</blockquote></div>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span></code>
+          shall be a pointer value obtained from <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Effects:</strong></span> Deallocates the storage referenced
+          by <code class="computeroutput"><span class="identifier">ptr</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Remark:</strong></span> Uses <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_free</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>.
+        </p>
+</blockquote></div>
+<pre class="programlisting"><span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> The largest value <code class="computeroutput"><span class="identifier">N</span></code> for which the call <code class="computeroutput"><span class="identifier">allocate</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
+          might succeed.
+        </p></blockquote></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">void</span> <span class="identifier">construct</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="special">::</span><span class="keyword">new</span><span class="special">((</span><span class="keyword">void</span><span class="special">*)</span><span class="identifier">ptr</span><span class="special">)</span> <span class="identifier">U</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">)...)</span></code>
+        </p></blockquote></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+<span class="keyword">void</span> <span class="identifier">destroy</span><span class="special">(</span><span class="identifier">U</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Effects:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span><span class="special">-&gt;~</span><span class="identifier">U</span><span class="special">()</span></code>
+        </p></blockquote></div>
+<h5>
+<a name="align.reference.aligned_allocator.h3"></a>
+        <span><a name="align.reference.aligned_allocator.globals"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator.globals">Globals</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">false</span></code>.
+        </p></blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.aligned_allocator_adaptor"></a><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor" title="aligned_allocator_adaptor">aligned_allocator_adaptor</a>
+</h3></div></div></div>
+<p>
+        The aligned allocator adaptor can turn any existing C++03 or C++11 allocator
+        into one that supports value types that are over-aligned. It also allows
+        specifying a minimum alignment value used for all allocations, via the optional
+        template parameter. An alignment aware allocator adaptor is not yet provided
+        by the C++ standard.
+      </p>
+<div class="tip"><table border="0" summary="Tip">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
+<th align="left">Tip</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          This adaptor can be used with a C++11 allocator whose pointer type is a
+          smart pointer but the adaptor can choose to expose only raw pointer types.
+        </p></td></tr>
+</table></div>
+<h5>
+<a name="align.reference.aligned_allocator_adaptor.h0"></a>
+        <span><a name="align.reference.aligned_allocator_adaptor.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.synopsis">Header
+        &lt;boost/align/aligned_allocator_adaptor.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">&gt;</span>
+    <span class="keyword">class</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A1</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A2</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A1</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A2</span><span class="special">,</span>
+      <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.aligned_allocator_adaptor.h1"></a>
+        <span><a name="align.reference.aligned_allocator_adaptor.aligned_allocator_adaptor"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.aligned_allocator_adaptor">Class
+        template aligned_allocator_adaptor</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span> <span class="special">=</span> <span class="number">1</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">aligned_allocator_adaptor</span>
+    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">Allocator</span> <span class="special">{</span>
+    <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator_traits</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;</span> <span class="identifier">Traits</span><span class="special">;</span> <span class="comment">// exposition</span>
+
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Traits</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Traits</span><span class="special">::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="identifier">value_type</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">*</span> <span class="identifier">const_pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">void_pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">const_void_pointer</span><span class="special">;</span>
+    <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
+        <span class="keyword">typedef</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Traits</span><span class="special">::</span><span class="keyword">template</span>
+            <span class="identifier">rebind_alloc</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;,</span> <span class="identifier">Alignment</span><span class="special">&gt;</span> <span class="identifier">other</span><span class="special">;</span>
+    <span class="special">};</span>
+
+    <span class="identifier">aligned_allocator_adaptor</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">A</span><span class="special">&gt;</span>
+    <span class="keyword">explicit</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="identifier">A</span><span class="special">&amp;&amp;</span> <span class="identifier">alloc</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+    <span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span>
+        <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
+
+    <span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="identifier">hint</span><span class="special">);</span>
+
+    <span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
+<span class="special">};</span>
+</pre>
+<h5>
+<a name="align.reference.aligned_allocator_adaptor.h2"></a>
+        <span><a name="align.reference.aligned_allocator_adaptor.constructors"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.constructors">Constructors</a>
+      </h5>
+<pre class="programlisting"><span class="identifier">aligned_allocator_adaptor</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Effects:</strong></span> Value-initializes the <code class="computeroutput"><span class="identifier">Allocator</span></code> base class.
+        </p></blockquote></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">A</span><span class="special">&gt;</span>
+<span class="keyword">explicit</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="identifier">A</span><span class="special">&amp;&amp;</span> <span class="identifier">alloc</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">Allocator</span></code>
+          shall be constructible from <code class="computeroutput"><span class="identifier">A</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Effects:</strong></span> Initializes the <code class="computeroutput"><span class="identifier">Allocator</span></code> base class with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;(</span><span class="identifier">alloc</span><span class="special">)</span></code>.
+        </p>
+</blockquote></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+<span class="identifier">aligned_allocator_adaptor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">Allocator</span></code>
+          shall be constructible from <code class="computeroutput"><span class="identifier">A</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Effects:</strong></span> Initializes the <code class="computeroutput"><span class="identifier">Allocator</span></code> base class with <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">base</span><span class="special">()</span></code>.
+        </p>
+</blockquote></div>
+<h5>
+<a name="align.reference.aligned_allocator_adaptor.h3"></a>
+        <span><a name="align.reference.aligned_allocator_adaptor.members"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.members">Members</a>
+      </h5>
+<pre class="programlisting"><span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&amp;&gt;(*</span><span class="keyword">this</span><span class="special">)</span></code>
+        </p></blockquote></div>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;&gt;(*</span><span class="keyword">this</span><span class="special">)</span></code>
+        </p></blockquote></div>
+<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Returns:</strong></span> A pointer to the initial element
+          of an array of storage of size <code class="computeroutput"><span class="identifier">n</span>
+          <span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">value_type</span><span class="special">)</span></code>, aligned on the maximum of the minimum
+          alignment specified and the alignment of objects of type <code class="computeroutput"><span class="identifier">value_type</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Remark:</strong></span> The storage is obtained by calling
+          <code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> on an object <code class="computeroutput"><span class="identifier">a2</span></code>,
+          where <code class="computeroutput"><span class="identifier">a2</span></code> of type <code class="computeroutput"><span class="identifier">A2</span></code> is a rebound copy of <code class="computeroutput"><span class="identifier">base</span><span class="special">()</span></code>
+          where its <code class="computeroutput"><span class="identifier">value_type</span></code> is
+          unspecified.
+        </p>
+<p>
+          <span class="bold"><strong>Throws:</strong></span> Throws an exception thrown from
+          <code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> if the storage cannot be obtained.
+        </p>
+</blockquote></div>
+<pre class="programlisting"><span class="identifier">pointer</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">const_void_pointer</span> <span class="identifier">hint</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">hint</span></code>
+          is a value obtained by calling <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code> on any equivalent aligned allocator adaptor
+          object, or else <code class="computeroutput"><span class="keyword">nullptr</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Returns:</strong></span> A pointer to the initial element
+          of an array of storage of size <code class="computeroutput"><span class="identifier">n</span>
+          <span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">value_type</span><span class="special">)</span></code>, aligned on the maximum of the minimum
+          alignment specified and the alignment of objects of type <code class="computeroutput"><span class="identifier">value_type</span></code>.
+        </p>
+<p>
+          <span class="bold"><strong>Remark:</strong></span> The storage is obtained by calling
+          <code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> on an object <code class="computeroutput"><span class="identifier">a2</span></code>,
+          where <code class="computeroutput"><span class="identifier">a2</span></code> of type <code class="computeroutput"><span class="identifier">A2</span></code> is a rebound copy of <code class="computeroutput"><span class="identifier">base</span><span class="special">()</span></code>
+          where its <code class="computeroutput"><span class="identifier">value_type</span></code> is
+          unspecified.
+        </p>
+<p>
+          <span class="bold"><strong>Throws:</strong></span> Throws an exception thrown from
+          <code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">allocate</span></code> if the storage cannot be obtained.
+        </p>
+</blockquote></div>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">(</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">ptr</span></code> shall be a pointer
+              value obtained from <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code>
+            </li>
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">size</span></code> shall equal the
+              value passed as the first argument to the invocation of <code class="computeroutput"><span class="identifier">allocate</span><span class="special">()</span></code>
+              which returned <code class="computeroutput"><span class="identifier">ptr</span></code>
+            </li>
+</ul></div>
+<p>
+          <span class="bold"><strong>Effects:</strong></span> Deallocates the storage referenced
+          by <code class="computeroutput"><span class="identifier">ptr</span></code>.
+        </p>
+</blockquote></div>
+<p>
+        <span class="bold"><strong>Note:</strong></span> Uses <code class="computeroutput"><span class="identifier">A2</span><span class="special">::</span><span class="identifier">deallocate</span></code>
+        on an object <code class="computeroutput"><span class="identifier">a2</span></code>, where <code class="computeroutput"><span class="identifier">a2</span></code> of type <code class="computeroutput"><span class="identifier">A2</span></code>
+        is a rebound copy of <code class="computeroutput"><span class="identifier">base</span><span class="special">()</span></code> where its <code class="computeroutput"><span class="identifier">value_type</span></code>
+        is unspecified.
+      </p>
+<h5>
+<a name="align.reference.aligned_allocator_adaptor.h4"></a>
+        <span><a name="align.reference.aligned_allocator_adaptor.globals"></a></span><a class="link" href="reference.html#align.reference.aligned_allocator_adaptor.globals">Globals</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A1</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A2</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="identifier">a1</span><span class="special">.</span><span class="identifier">base</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a2</span><span class="special">.</span><span class="identifier">base</span><span class="special">()</span></code>
+        </p></blockquote></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</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">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A1</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a1</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">A2</span><span class="special">,</span>
+    <span class="identifier">Alignment</span><span class="special">&gt;&amp;</span> <span class="identifier">a2</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a1</span> <span class="special">==</span> <span class="identifier">a2</span><span class="special">)</span></code>
+        </p></blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.aligned_delete"></a><a class="link" href="reference.html#align.reference.aligned_delete" title="aligned_delete">aligned_delete</a>
+</h3></div></div></div>
+<p>
+        The aligned deleter class is convenient utility for destroying and then deallocating
+        the constructed objects that were allocated using aligned allocation function
+        provided in this library. It serves as a replacement for the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">default_delete</span></code>
+        class for this case.
+      </p>
+<h5>
+<a name="align.reference.aligned_delete.h0"></a>
+        <span><a name="align.reference.aligned_delete.synopsis"></a></span><a class="link" href="reference.html#align.reference.aligned_delete.synopsis">Header
+        &lt;boost/align/aligned_delete.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">class</span> <span class="identifier">aligned_delete</span><span class="special">;</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.aligned_delete.h1"></a>
+        <span><a name="align.reference.aligned_delete.aligned_delete"></a></span><a class="link" href="reference.html#align.reference.aligned_delete.aligned_delete">Class
+        aligned_delete</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">aligned_delete</span> <span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+    <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">-&gt;~</span><span class="identifier">T</span><span class="special">()));</span>
+<span class="special">};</span>
+</pre>
+<h5>
+<a name="align.reference.aligned_delete.h2"></a>
+        <span><a name="align.reference.aligned_delete.members"></a></span><a class="link" href="reference.html#align.reference.aligned_delete.members">Members</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">(</span><span class="keyword">noexcept</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">-&gt;~</span><span class="identifier">T</span><span class="special">()));</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Effects:</strong></span> Calls <code class="computeroutput"><span class="special">~</span><span class="identifier">T</span><span class="special">()</span></code> on
+          <code class="computeroutput"><span class="identifier">ptr</span></code> to destroy the object
+          and then calls <code class="computeroutput"><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_free</span></code>
+          on <code class="computeroutput"><span class="identifier">ptr</span></code> to free the allocated
+          memory.
+        </p>
+<p>
+          <span class="bold"><strong>Note:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code>
+          is an incomplete type, the program is ill-formed.
+        </p>
+</blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.alignment_of"></a><a class="link" href="reference.html#align.reference.alignment_of" title="alignment_of">alignment_of</a>
+</h3></div></div></div>
+<p>
+        The alignment type trait is used to query the alignment requirement of a
+        type at compile time. It is provided by the C++11 standard library but is
+        provided in this library for C++11 and C++03 implementations that do not
+        provide this functionality.
+      </p>
+<h5>
+<a name="align.reference.alignment_of.h0"></a>
+        <span><a name="align.reference.alignment_of.synopsis"></a></span><a class="link" href="reference.html#align.reference.alignment_of.synopsis">Header
+        &lt;boost/align/alignment_of.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+    <span class="keyword">struct</span> <span class="identifier">alignment_of</span><span class="special">;</span>
+
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+    <span class="keyword">constexpr</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment_of_v</span> <span class="special">=</span> <span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.alignment_of.h1"></a>
+        <span><a name="align.reference.alignment_of.alignment_of"></a></span><a class="link" href="reference.html#align.reference.alignment_of.alignment_of">Type
+        trait alignment_of</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">alignment_of</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Value:</strong></span> The alignment requirement of the
+          type <code class="computeroutput"><span class="identifier">T</span></code> as an integral constant
+          of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>. When <code class="computeroutput"><span class="identifier">T</span></code>
+          is a reference array type, the value shall be the alignment of the referenced
+          type. When <code class="computeroutput"><span class="identifier">T</span></code> is an array
+          type, the value shall be the alignment of the element type.
+        </p>
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
+          shall be a complete object type, or an array thereof, or a reference to
+          one of those types.
+        </p>
+</blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.assume_aligned"></a><a class="link" href="reference.html#align.reference.assume_aligned" title="assume_aligned">assume_aligned</a>
+</h3></div></div></div>
+<p>
+        The alignment hint macro can be used to inform the compiler of the alignment
+        of a memory block, to enable vectorizing or other compiler specific alignment
+        related optimizations.
+      </p>
+<h5>
+<a name="align.reference.assume_aligned.h0"></a>
+        <span><a name="align.reference.assume_aligned.synopsis"></a></span><a class="link" href="reference.html#align.reference.assume_aligned.synopsis">Header
+        &lt;boost/align/assume_aligned.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="identifier">BOOST_ALIGN_ASSUME_ALIGNED</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">)</span>
+</pre>
+<h5>
+<a name="align.reference.assume_aligned.h1"></a>
+        <span><a name="align.reference.assume_aligned.assume_aligned"></a></span><a class="link" href="reference.html#align.reference.assume_aligned.assume_aligned">Macro
+        BOOST_ALIGN_ASSUME_ALIGNED</a>
+      </h5>
+<pre class="programlisting"><span class="identifier">BOOST_ALIGN_ASSUME_ALIGNED</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">alignment</span><span class="special">)</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span>
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">alignment</span></code> shall be
+              a power of two
+            </li>
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">ptr</span></code> shall be mutable
+            </li>
+</ul></div>
+<p>
+          <span class="bold"><strong>Effect:</strong></span> <code class="computeroutput"><span class="identifier">ptr</span></code>
+          may be modified in an implementation specific way to inform the compiler
+          of its alignment.
+        </p>
+</blockquote></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.reference.is_aligned"></a><a class="link" href="reference.html#align.reference.is_aligned" title="is_aligned">is_aligned</a>
+</h3></div></div></div>
+<p>
+        The alignment validation function indicates whether or not an address is
+        a multiple of the specified alignment value. It is generally useful in assertions
+        to verify memory is correctly aligned. This functionality is not yet provided
+        by the C++ standard.
+      </p>
+<h5>
+<a name="align.reference.is_aligned.h0"></a>
+        <span><a name="align.reference.is_aligned.synopsis"></a></span><a class="link" href="reference.html#align.reference.is_aligned.synopsis">Header
+        &lt;boost/align/is_aligned.hpp&gt;</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+  <span class="keyword">namespace</span> <span class="identifier">alignment</span> <span class="special">{</span>
+    <span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_aligned</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span>
+      <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+
+    <span class="keyword">bool</span> <span class="identifier">is_aligned</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+  <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<h5>
+<a name="align.reference.is_aligned.h1"></a>
+        <span><a name="align.reference.is_aligned.is_aligned"></a></span><a class="link" href="reference.html#align.reference.is_aligned.is_aligned">Function
+        is_aligned</a>
+      </h5>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_aligned</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">alignment</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">alignment</span></code>
+          shall be a power of two.
+        </p>
+<p>
+          <span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
+          if the value of <code class="computeroutput"><span class="identifier">ptr</span></code> is
+          aligned on the boundary specified by <code class="computeroutput"><span class="identifier">alignment</span></code>,
+          otherwise <code class="computeroutput"><span class="keyword">false</span></code>.
+        </p>
+</blockquote></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="examples.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="vocabulary.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/align/tutorial.html b/libs/align/doc/html/align/tutorial.html
new file mode 100644
index 0000000000..751e9f9371
--- /dev/null
+++ b/libs/align/doc/html/align/tutorial.html
@@ -0,0 +1,314 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Tutorial</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="rationale.html" title="Rationale">
+<link rel="next" href="examples.html" title="Examples">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="rationale.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="examples.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.tutorial"></a><a class="link" href="tutorial.html" title="Tutorial">Tutorial</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.align">align</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.aligned_alloc">aligned_alloc and aligned_free</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.aligned_allocator">aligned_allocator</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.aligned_allocator_adaptor">aligned_allocator_adaptor</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.aligned_delete">aligned_delete</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.alignment_of">alignment_of</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.assume_aligned">assume_aligned</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#align.tutorial.is_aligned">is_aligned</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.align"></a><a class="link" href="tutorial.html#align.tutorial.align" title="align">align</a>
+</h3></div></div></div>
+<p>
+        The alignment function can be used to find the first address of a given alignment
+        value within a given buffer of a given size. It adjusts the pointer provided,
+        returns that value, and decreases space by the amount advanced, if the alignment
+        succeeds, provided sufficient space in the buffer. Otherwise it yields a
+        null pointer to indicate failure due to insufficient space.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">align</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">alignment_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="keyword">new</span><span class="special">&gt;</span>
+
+<span class="keyword">struct</span> <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="identifier">type</span> <span class="special">{</span>
+    <span class="keyword">float</span> <span class="identifier">data</span><span class="special">[</span><span class="number">4</span><span class="special">];</span>
+<span class="special">};</span>
+
+<span class="keyword">void</span> <span class="identifier">use</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="keyword">auto</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">align</span><span class="special">(</span><span class="number">16</span><span class="special">,</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">type</span><span class="special">),</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+    <span class="keyword">if</span> <span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="special">{</span>
+        <span class="keyword">auto</span> <span class="identifier">q</span> <span class="special">=</span> <span class="special">::</span><span class="keyword">new</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="identifier">type</span><span class="special">;</span>
+        <span class="identifier">q</span><span class="special">-&gt;~</span><span class="identifier">type</span><span class="special">();</span>
+    <span class="special">}</span>
+<span class="special">}</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">char</span> <span class="identifier">c</span><span class="special">[</span><span class="number">64</span><span class="special">];</span>
+    <span class="identifier">use</span><span class="special">(</span><span class="identifier">c</span><span class="special">,</span> <span class="keyword">sizeof</span> <span class="identifier">c</span><span class="special">);</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.aligned_alloc"></a><a class="link" href="tutorial.html#align.tutorial.aligned_alloc" title="aligned_alloc and aligned_free">aligned_alloc and aligned_free</a>
+</h3></div></div></div>
+<p>
+        Consider these functions alignment enabled versions of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">malloc</span></code>,
+        <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">free</span></code> or <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span> <span class="keyword">new</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">no_throw_t</span><span class="special">&amp;)</span></code>, <code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span> <span class="keyword">delete</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code>.
+        The aligned allocation function allocates space with the specified size and
+        alignment. The aligned deallocation function can then deallocate this space.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_alloc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">void</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_alloc</span><span class="special">(</span><span class="number">16</span><span class="special">,</span> <span class="number">100</span><span class="special">);</span>
+    <span class="keyword">if</span> <span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="special">{</span>
+        <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_free</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span>
+    <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.aligned_allocator"></a><a class="link" href="tutorial.html#align.tutorial.aligned_allocator" title="aligned_allocator">aligned_allocator</a>
+</h3></div></div></div>
+<p>
+        Consider this class template a superior version of the default allocator,
+        <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span></code>, because it can be used with
+        types that are over-aligned.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_allocator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
+
+<span class="keyword">struct</span> <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="identifier">type</span> <span class="special">{</span>
+    <span class="keyword">float</span> <span class="identifier">data</span><span class="special">[</span><span class="number">4</span><span class="special">];</span>
+<span class="special">};</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">,</span>
+        <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
+    <span class="identifier">v</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">();</span>
+<span class="special">}</span>
+</pre>
+<p>
+        The optional template parameter of this class allows specifying a minimum
+        alignment to use for allocations. The default minimum alignment is 1.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_allocator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span>
+        <span class="identifier">aligned_allocator</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="number">16</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
+    <span class="identifier">v</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">();</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.aligned_allocator_adaptor"></a><a class="link" href="tutorial.html#align.tutorial.aligned_allocator_adaptor" title="aligned_allocator_adaptor">aligned_allocator_adaptor</a>
+</h3></div></div></div>
+<p>
+        This class template can turn any existing allocator type, C++11 or C++03,
+        stateful or stateless, into one that supports types which are over-aligned.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_allocator_adaptor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">utility</span> <span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">void</span> <span class="identifier">add</span><span class="special">()</span> <span class="special">{</span>
+        <span class="identifier">v</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">();</span>
+    <span class="special">}</span>
+<span class="keyword">private</span><span class="special">:</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span>
+        <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">struct</span> <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="identifier">type</span> <span class="special">{</span>
+    <span class="keyword">float</span> <span class="identifier">data</span><span class="special">[</span><span class="number">4</span><span class="special">];</span>
+<span class="special">};</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="identifier">utility</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">u</span><span class="special">;</span>
+    <span class="identifier">u</span><span class="special">.</span><span class="identifier">add</span><span class="special">();</span>
+<span class="special">}</span>
+</pre>
+<p>
+        The optional template parameter of this class allows specifying a minimum
+        alignment to use for allocations. The default minimum alignment is 1.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_allocator_adaptor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Alignment</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">utility</span> <span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">void</span> <span class="identifier">add</span><span class="special">()</span> <span class="special">{</span>
+        <span class="identifier">v</span><span class="special">.</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">emplace_back</span><span class="special">();</span>
+    <span class="special">}</span>
+<span class="keyword">private</span><span class="special">:</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span>
+        <span class="identifier">aligned_allocator_adaptor</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">,</span> <span class="identifier">Alignment</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="identifier">utility</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;,</span> <span class="number">16</span><span class="special">&gt;</span> <span class="identifier">u</span><span class="special">;</span>
+    <span class="identifier">u</span><span class="special">.</span><span class="identifier">add</span><span class="special">();</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.aligned_delete"></a><a class="link" href="tutorial.html#align.tutorial.aligned_delete" title="aligned_delete">aligned_delete</a>
+</h3></div></div></div>
+<p>
+        Consider this class an alignment aware version of the class template <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">default_delete</span></code>.
+        It is a deleter that destroys the object and then deallocates space using
+        our aligned deallocation function. It should be used with constructed objects
+        that were allocated with our aligned allocation function and is useful with
+        deleter enabled types like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span></code>.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">aligned_delete</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">memory</span><span class="special">&gt;</span>
+
+<span class="keyword">struct</span> <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="identifier">type</span> <span class="special">{</span>
+    <span class="keyword">float</span> <span class="identifier">data</span><span class="special">[</span><span class="number">4</span><span class="special">];</span>
+<span class="special">};</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">void</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_alloc</span><span class="special">(</span><span class="number">16</span><span class="special">,</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">type</span><span class="special">));</span>
+    <span class="keyword">if</span> <span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="special">{</span>
+       <span class="identifier">type</span><span class="special">*</span> <span class="identifier">q</span> <span class="special">=</span> <span class="special">::</span><span class="keyword">new</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="identifier">type</span><span class="special">;</span>
+       <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_ptr</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">aligned_delete</span><span class="special">&gt;(</span><span class="identifier">q</span><span class="special">);</span>
+    <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.alignment_of"></a><a class="link" href="tutorial.html#align.tutorial.alignment_of" title="alignment_of">alignment_of</a>
+</h3></div></div></div>
+<p>
+        This type trait can be used to query the alignment requirement of a type
+        at compile time.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">alignment_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">utility</span> <span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">void</span> <span class="identifier">construct</span><span class="special">()</span> <span class="special">{</span>
+        <span class="keyword">void</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">v</span><span class="special">;</span>
+        <span class="special">::</span><span class="keyword">new</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="identifier">T</span><span class="special">();</span>
+    <span class="special">}</span>
+<span class="keyword">private</span><span class="special">:</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">aligned_storage_t</span><span class="special">&lt;</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">),</span>
+        <span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">alignment_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">struct</span> <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="identifier">type</span> <span class="special">{</span>
+    <span class="keyword">float</span> <span class="identifier">data</span><span class="special">[</span><span class="number">4</span><span class="special">];</span>
+<span class="special">};</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="identifier">utility</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">&gt;</span> <span class="identifier">u</span><span class="special">;</span>
+    <span class="identifier">u</span><span class="special">.</span><span class="identifier">construct</span><span class="special">();</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.assume_aligned"></a><a class="link" href="tutorial.html#align.tutorial.assume_aligned" title="assume_aligned">assume_aligned</a>
+</h3></div></div></div>
+<p>
+        This macro is used to notify the compiler of a given pointer variable's alignment.
+        It is useful for guide optimizing compilers into vectorizing or applying
+        other compiler specific, alignment related optimizations.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">assume_aligned</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+
+<span class="keyword">void</span> <span class="identifier">use</span><span class="special">(</span><span class="keyword">double</span><span class="special">*</span> <span class="identifier">array</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">BOOST_ALIGN_ASSUME_ALIGNED</span><span class="special">(</span><span class="identifier">array</span><span class="special">,</span> <span class="number">16</span><span class="special">);</span>
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">;</span> <span class="identifier">i</span><span class="special">++)</span> <span class="special">{</span>
+        <span class="identifier">array</span><span class="special">[</span><span class="identifier">i</span><span class="special">]++;</span>
+    <span class="special">}</span>
+<span class="special">}</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="keyword">double</span> <span class="identifier">d</span><span class="special">[</span><span class="number">4</span><span class="special">]</span> <span class="special">{</span> <span class="special">};</span>
+    <span class="identifier">use</span><span class="special">(</span><span class="identifier">d</span><span class="special">,</span> <span class="number">4</span><span class="special">);</span>
+<span class="special">}</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="align.tutorial.is_aligned"></a><a class="link" href="tutorial.html#align.tutorial.is_aligned" title="is_aligned">is_aligned</a>
+</h3></div></div></div>
+<p>
+        This function is used to compare the alignment of a pointer. It is useful
+        in assertions that validate a pointer value is aligned on a given boundary.
+      </p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">align</span><span class="special">/</span><span class="identifier">is_aligned</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cassert</span><span class="special">&gt;</span>
+
+<span class="keyword">void</span> <span class="identifier">use</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">assert</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">alignment</span><span class="special">::</span><span class="identifier">is_aligned</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">,</span> <span class="number">16</span><span class="special">));</span>
+<span class="special">}</span>
+
+<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
+<span class="special">{</span>
+    <span class="keyword">alignas</span><span class="special">(</span><span class="number">16</span><span class="special">)</span> <span class="keyword">char</span> <span class="identifier">c</span><span class="special">[</span><span class="number">64</span><span class="special">];</span>
+    <span class="identifier">use</span><span class="special">(</span><span class="identifier">c</span><span class="special">);</span>
+<span class="special">}</span>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="rationale.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="examples.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/align/vocabulary.html b/libs/align/doc/html/align/vocabulary.html
new file mode 100644
index 0000000000..7a0f2732a7
--- /dev/null
+++ b/libs/align/doc/html/align/vocabulary.html
@@ -0,0 +1,165 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Vocabulary</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="prev" href="reference.html" title="Reference">
+<link rel="next" href="compatibility.html" title="Compatibility">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="compatibility.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.vocabulary"></a><a class="link" href="vocabulary.html" title="Vocabulary">Vocabulary</a>
+</h2></div></div></div>
+<h4>
+<a name="align.vocabulary.h0"></a>
+      <span><a name="align.vocabulary.basic_align"></a></span><a class="link" href="vocabulary.html#align.vocabulary.basic_align">[basic.align]</a>
+    </h4>
+<p>
+      Object types have <span class="bold"><strong>alignment requirements</strong></span> which
+      place restrictions on the addresses at which an object of that type may be
+      allocated. An <span class="bold"><strong>alignment</strong></span> is an implementation-defined
+      integer value representing the number of bytes between successive addresses
+      at which a given object can be allocated. An object type imposes an alignment
+      requirement on every object of that type; stricter alignment can be requested
+      using the alignment specifier.
+    </p>
+<p>
+      A <span class="bold"><strong>fundamental alignment</strong></span> is represented by
+      an alignment less than or equal to the greatest alignment supported by the
+      implementation in all contexts, which is equal to <code class="computeroutput"><span class="keyword">alignof</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">max_align_t</span><span class="special">)</span></code>.
+      The alignment required for a type might be different when it is used as the
+      type of a complete object and when it is used as the type of a subobject.
+    </p>
+<div class="tip"><table border="0" summary="Tip">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../doc/src/images/tip.png"></td>
+<th align="left">Tip</th>
+</tr>
+<tr><td align="left" valign="top">
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="identifier">d</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">D</span> <span class="special">:</span> <span class="keyword">virtual</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">char</span> <span class="identifier">c</span><span class="special">;</span> <span class="special">};</span>
+</pre>
+<p>
+        When <code class="computeroutput"><span class="identifier">D</span></code> is the type of a complete
+        object, it will have a subobject of type <code class="computeroutput"><span class="identifier">B</span></code>,
+        so it must be aligned appropriately for a <code class="computeroutput"><span class="keyword">long</span>
+        <span class="keyword">double</span></code>. If <code class="computeroutput"><span class="identifier">D</span></code>
+        appears as a subobject of another object that also has <code class="computeroutput"><span class="identifier">B</span></code>
+        as a virtual base class, the <code class="computeroutput"><span class="identifier">B</span></code>
+        subobject might be part of a different subobject, reducing the alignment
+        requirements on the <code class="computeroutput"><span class="identifier">D</span></code> subobject.
+      </p>
+</td></tr>
+</table></div>
+<p>
+      The result of the <code class="computeroutput"><span class="keyword">alignof</span></code> operator
+      reflects the alignment requirement of the type in the complete-object case.
+    </p>
+<p>
+      An <span class="bold"><strong>extended alignment</strong></span> is represented by an
+      alignment greater than <code class="computeroutput"><span class="keyword">alignof</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">max_align_t</span><span class="special">)</span></code>.
+      It is implementation-defined whether any extended alignments are supported
+      and the contexts in which they are supported. A type having an extended alignment
+      requirement is an <span class="bold"><strong>over-aligned type</strong></span>.
+    </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+        Every over-aligned type is or contains a class type to which extended alignment
+        applies (possibly through a non-static data member).
+      </p></td></tr>
+</table></div>
+<p>
+      Alignments are represented as values of the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>.
+      Valid alignments include only those values returned by an <code class="computeroutput"><span class="keyword">alignof</span></code>
+      expression for the fundamental types plus an additional implementation-defined
+      set of values, which may be empty. Every alignment value shall be a non-negative
+      integral power of two.
+    </p>
+<p>
+      Alignments have an order from <span class="bold"><strong>weaker</strong></span> to <span class="bold"><strong>stronger</strong></span> or <span class="bold"><strong>stricter</strong></span>
+      alignments. Stricter alignments have larger alignment values. An address that
+      satisfies an alignment requirement also satisfies any weaker valid alignment
+      requirement.
+    </p>
+<p>
+      The alignment requirement of a complete type can be queried using an <code class="computeroutput"><span class="keyword">alignof</span></code> expression. Furthermore, the types
+      <code class="computeroutput"><span class="keyword">char</span></code>, <code class="computeroutput"><span class="keyword">signed</span>
+      <span class="keyword">char</span></code>, and <code class="computeroutput"><span class="keyword">unsigned</span>
+      <span class="keyword">char</span></code> shall have the weakest alignment
+      requirement.
+    </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+        This enables the character types to be used as the underlying type for an
+        aligned memory area.
+      </p></td></tr>
+</table></div>
+<p>
+      Comparing alignments is meaningful and provides the obvious results:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Two alignments are equal when their numeric values are equal.
+        </li>
+<li class="listitem">
+          Two alignments are different when their numeric values are not equal.
+        </li>
+<li class="listitem">
+          When an alignment is larger than another it represents a stricter alignment.
+        </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+        The runtime pointer alignment function can be used to obtain an aligned pointer
+        within a buffer; the aligned-storage templates in the library can be used
+        to obtain aligned storage.
+      </p></td></tr>
+</table></div>
+<p>
+      If a request for a specific extended alignment in a specific context is not
+      supported by an implementation, the program is ill-formed. Additionally, a
+      request for runtime allocation of dynamic storage for which the requested alignment
+      cannot be honored shall be treated as an allocation failure.
+    </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2014, 2015 Glen Joseph Fernandes<p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="reference.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="compatibility.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
diff --git a/libs/align/doc/html/index.html b/libs/align/doc/html/index.html
new file mode 100644
index 0000000000..a543cd00b8
--- /dev/null
+++ b/libs/align/doc/html/index.html
@@ -0,0 +1,226 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter&#160;1.&#160;Boost.Align</title>
+<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="index.html" title="Chapter&#160;1.&#160;Boost.Align">
+<link rel="next" href="align/rationale.html" title="Rationale">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center"><a href="../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="align/rationale.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+<div class="chapter">
+<div class="titlepage"><div>
+<div><h2 class="title">
+<a name="align"></a>Chapter&#160;1.&#160;Boost.Align</h2></div>
+<div><div class="author"><h3 class="author">
+<span class="firstname">Glen</span> <span class="surname">Fernandes</span>
+</h3></div></div>
+<div><p class="copyright">Copyright &#169; 2014, 2015 Glen Joseph Fernandes</p></div>
+<div><div class="legalnotice">
+<a name="align.legal"></a><p>
+        Distributed under the Boost Software License, Version 1.0.
+      </p>
+</div></div>
+</div></div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<dt><span class="section"><a href="index.html#align.introduction">Introduction</a></span></dt>
+<dt><span class="section"><a href="align/rationale.html">Rationale</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html">Tutorial</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.align">align</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.aligned_alloc">aligned_alloc and aligned_free</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.aligned_allocator">aligned_allocator</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.aligned_allocator_adaptor">aligned_allocator_adaptor</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.aligned_delete">aligned_delete</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.alignment_of">alignment_of</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.assume_aligned">assume_aligned</a></span></dt>
+<dt><span class="section"><a href="align/tutorial.html#align.tutorial.is_aligned">is_aligned</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="align/examples.html">Examples</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="align/examples.html#align.examples.aligned_ptr">aligned_ptr and make_aligned</a></span></dt>
+<dt><span class="section"><a href="align/examples.html#align.examples.aligned_vector">aligned_vector</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="align/reference.html">Reference</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="align/reference.html#align.reference.align">align</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.align_down">align_down</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.align_up">align_up</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.aligned_alloc">aligned_alloc and aligned_free</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.aligned_allocator">aligned_allocator</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.aligned_allocator_adaptor">aligned_allocator_adaptor</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.aligned_delete">aligned_delete</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.alignment_of">alignment_of</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.assume_aligned">assume_aligned</a></span></dt>
+<dt><span class="section"><a href="align/reference.html#align.reference.is_aligned">is_aligned</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="align/vocabulary.html">Vocabulary</a></span></dt>
+<dt><span class="section"><a href="align/compatibility.html">Compatibility</a></span></dt>
+<dt><span class="section"><a href="align/acknowledgments.html">Acknowledgments</a></span></dt>
+<dt><span class="section"><a href="align/history.html">History</a></span></dt>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="align.introduction"></a><a class="link" href="index.html#align.introduction" title="Introduction">Introduction</a>
+</h2></div></div></div>
+<p>
+      This library provides an alignment function, aligned allocation and deallocation
+      functions, an aligned allocator, an aligned allocator adaptor, an aligned deleter,
+      a type trait to query alignment requirements, a macro to hint pointer alignment,
+      and a function to verify pointer value alignment.
+    </p>
+<div class="table">
+<a name="align.introduction.the_boost_align_library"></a><p class="title"><b>Table&#160;1.1.&#160;The Boost.Align Library</b></p>
+<div class="table-contents"><table class="table" summary="The Boost.Align Library">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+                Component
+              </p>
+            </th>
+<th>
+              <p>
+                Description
+              </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">align</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Pointer alignment function
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">align_up</span></code>, <code class="computeroutput"><span class="identifier">align_down</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Pointer and integral alignment functions
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_alloc</span></code>, <code class="computeroutput"><span class="identifier">aligned_free</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Aligned allocation and deallocation functions
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_allocator</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Alignment aware allocator
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_allocator_adaptor</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Alignment aware allocator adaptor
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">aligned_delete</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Deleter for deallocation of aligned allocations
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">alignment_of</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Trait to query alignment requirement of a type
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">assume_aligned</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Macro for static pointer alignment hint
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                <code class="computeroutput"><span class="identifier">is_aligned</span></code>
+              </p>
+            </td>
+<td>
+              <p>
+                Pointer and integral alignment checking
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: May 05, 2016 at 21:18:23 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="align/rationale.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
+</body>
+</html>
diff --git a/libs/align/doc/html/standalone_HTML.manifest b/libs/align/doc/html/standalone_HTML.manifest
new file mode 100644
index 0000000000..b9df23c2a8
--- /dev/null
+++ b/libs/align/doc/html/standalone_HTML.manifest
@@ -0,0 +1,9 @@
+index.html
+align/rationale.html
+align/tutorial.html
+align/examples.html
+align/reference.html
+align/vocabulary.html
+align/compatibility.html
+align/acknowledgments.html
+align/history.html
diff --git a/libs/align/test/Jamfile.v2 b/libs/align/test/Jamfile.v2
index 065da44ab9..530f659ed2 100644
--- a/libs/align/test/Jamfile.v2
+++ b/libs/align/test/Jamfile.v2
@@ -8,6 +8,8 @@
 import testing ;
 
 run align_test.cpp ;
+run align_down_test.cpp ;
+run align_up_test.cpp ;
 run aligned_alloc_test.cpp ;
 run aligned_allocator_test.cpp ;
 run aligned_allocator_adaptor_test.cpp ;
diff --git a/libs/align/test/align_down_test.cpp b/libs/align/test/align_down_test.cpp
new file mode 100644
index 0000000000..827959c129
--- /dev/null
+++ b/libs/align/test/align_down_test.cpp
@@ -0,0 +1,44 @@
+/*
+(c) 2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/align/align_down.hpp>
+#include <boost/align/is_aligned.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<std::size_t Alignment>
+void test()
+{
+    char s[Alignment << 1];
+    char* b = s;
+    while (!boost::alignment::is_aligned(b, Alignment)) {
+        b++;
+    }
+    {
+        void* p = &b[Alignment];
+        BOOST_TEST(boost::alignment::align_down(p, Alignment) == p);
+    }
+    {
+        void* p = &b[Alignment - 1];
+        void* q = b;
+        BOOST_TEST(boost::alignment::align_down(p, Alignment) == q);
+    }
+}
+
+int main()
+{
+    test<1>();
+    test<2>();
+    test<4>();
+    test<8>();
+    test<16>();
+    test<32>();
+    test<64>();
+    test<128>();
+
+    return boost::report_errors();
+}
diff --git a/libs/align/test/align_test.cpp b/libs/align/test/align_test.cpp
index 2996eea5ae..624c687357 100644
--- a/libs/align/test/align_test.cpp
+++ b/libs/align/test/align_test.cpp
@@ -1,5 +1,5 @@
 /*
-(c) 2014 Glen Joseph Fernandes
+(c) 2014-2015 Glen Joseph Fernandes
 <glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
@@ -9,14 +9,13 @@ http://boost.org/LICENSE_1_0.txt
 #include <boost/align/align.hpp>
 #include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <cstddef>
 
 template<std::size_t Alignment>
 void test()
 {
     char s[Alignment << 1];
     char* b = s;
-    while (!boost::alignment::is_aligned(Alignment, b)) {
+    while (!boost::alignment::is_aligned(b, Alignment)) {
         b++;
     }
     {
@@ -25,10 +24,18 @@ void test()
         void* q = boost::alignment::align(Alignment, 1, p, n);
         BOOST_TEST(q == p);
         BOOST_TEST(q == b);
-        BOOST_TEST(boost::alignment::is_aligned(Alignment, q));
+        BOOST_TEST(boost::alignment::is_aligned(q, Alignment));
         BOOST_TEST(n == Alignment);
     }
     {
+        std::size_t n = 0;
+        void* p = b;
+        void* q = boost::alignment::align(Alignment, 1, p, n);
+        BOOST_TEST(q == 0);
+        BOOST_TEST(p == b);
+        BOOST_TEST(n == 0);
+    }
+    {
         std::size_t n = Alignment - 1;
         void* p = &b[1];
         void* q = boost::alignment::align(Alignment, 1, p, n);
@@ -42,7 +49,7 @@ void test()
         void* q = boost::alignment::align(Alignment, 1, p, n);
         BOOST_TEST(q == p);
         BOOST_TEST(p == &b[Alignment]);
-        BOOST_TEST(boost::alignment::is_aligned(Alignment, q));
+        BOOST_TEST(boost::alignment::is_aligned(q, Alignment));
         BOOST_TEST(n == 1);
     }
 }
diff --git a/libs/align/test/align_up_test.cpp b/libs/align/test/align_up_test.cpp
new file mode 100644
index 0000000000..7a3c7008cf
--- /dev/null
+++ b/libs/align/test/align_up_test.cpp
@@ -0,0 +1,44 @@
+/*
+(c) 2015 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#include <boost/align/align_up.hpp>
+#include <boost/align/is_aligned.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<std::size_t Alignment>
+void test()
+{
+    char s[Alignment << 1];
+    char* b = s;
+    while (!boost::alignment::is_aligned(b, Alignment)) {
+        b++;
+    }
+    {
+        void* p = b;
+        BOOST_TEST(boost::alignment::align_up(p, Alignment) == p);
+    }
+    {
+        void* p = &b[Alignment];
+        void* q = &b[1];
+        BOOST_TEST(boost::alignment::align_up(q, Alignment) == p);
+    }
+}
+
+int main()
+{
+    test<1>();
+    test<2>();
+    test<4>();
+    test<8>();
+    test<16>();
+    test<32>();
+    test<64>();
+    test<128>();
+
+    return boost::report_errors();
+}
diff --git a/libs/align/test/aligned_alloc_test.cpp b/libs/align/test/aligned_alloc_test.cpp
index a75ba0e32b..2c10e06e5a 100644
--- a/libs/align/test/aligned_alloc_test.cpp
+++ b/libs/align/test/aligned_alloc_test.cpp
@@ -9,7 +9,6 @@ http://boost.org/LICENSE_1_0.txt
 #include <boost/align/aligned_alloc.hpp>
 #include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <cstddef>
 #include <cstring>
 
 void test(std::size_t alignment)
@@ -18,7 +17,7 @@ void test(std::size_t alignment)
         void* p = boost::alignment::aligned_alloc(alignment,
             alignment);
         BOOST_TEST(p != 0);
-        BOOST_TEST(boost::alignment::is_aligned(alignment, p));
+        BOOST_TEST(boost::alignment::is_aligned(p, alignment));
         std::memset(p, 0, 1);
         boost::alignment::aligned_free(p);
     }
@@ -26,7 +25,7 @@ void test(std::size_t alignment)
         void* p = boost::alignment::aligned_alloc(alignment,
             alignment + 1);
         BOOST_TEST(p != 0);
-        BOOST_TEST(boost::alignment::is_aligned(alignment, p));
+        BOOST_TEST(boost::alignment::is_aligned(p, alignment));
         std::memset(p, 0, 1);
         boost::alignment::aligned_free(p);
     }
@@ -34,7 +33,7 @@ void test(std::size_t alignment)
         void* p = boost::alignment::aligned_alloc(alignment,
             alignment - 1);
         BOOST_TEST(p != 0);
-        BOOST_TEST(boost::alignment::is_aligned(alignment, p));
+        BOOST_TEST(boost::alignment::is_aligned(p, alignment));
         std::memset(p, 0, 1);
         boost::alignment::aligned_free(p);
     } else {
diff --git a/libs/align/test/aligned_allocator_adaptor_test.cpp b/libs/align/test/aligned_allocator_adaptor_test.cpp
index 470b42d63e..cd75d83c39 100644
--- a/libs/align/test/aligned_allocator_adaptor_test.cpp
+++ b/libs/align/test/aligned_allocator_adaptor_test.cpp
@@ -10,11 +10,10 @@ http://boost.org/LICENSE_1_0.txt
 #include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <new>
-#include <cstddef>
 #include <cstring>
 
 template<class T>
-class simple {
+class A {
 public:
     typedef T value_type;
     typedef T* pointer;
@@ -25,55 +24,44 @@ public:
     typedef std::ptrdiff_t difference_type;
     typedef T& reference;
     typedef const T& const_reference;
-
     template<class U>
     struct rebind {
-        typedef simple<U> other;
+        typedef A<U> other;
     };
-
-    simple()
+    A()
         : state() {
     }
-
-    simple(int value)
+    A(int value)
         : state(value) {
     }
-
     template<class U>
-    simple(const simple<U>& other)
+    A(const A<U>& other)
         : state(other.state) {
     }
-
     pointer allocate(size_type size, const_void_pointer = 0) {
-        void* p = ::operator new(sizeof(T) * size);
-        return static_cast<T*>(p);
+        return static_cast<T*>(::operator new(sizeof(T) * size));
     }
-
     void deallocate(pointer ptr, size_type) {
         ::operator delete(ptr);
     }
-
     void construct(pointer ptr, const_reference value) {
-        void* p = ptr;
-        ::new(p) T(value);
+        ::new(static_cast<void*>(ptr)) T(value);
     }
-
     void destroy(pointer ptr) {
         (void)ptr;
         ptr->~T();
     }
-
     int state;
 };
 
 template<class T1, class T2>
-bool operator==(const simple<T1>& a, const simple<T2>& b)
+bool operator==(const A<T1>& a, const A<T2>& b)
 {
     return a.state == b.state;
 }
 
 template<class T1, class T2>
-bool operator!=(const simple<T1>& a, const simple<T2>& b)
+bool operator!=(const A<T1>& a, const A<T2>& b)
 {
     return !(a == b);
 }
@@ -82,27 +70,27 @@ template<std::size_t Alignment>
 void test_allocate()
 {
     {
-        boost::alignment::aligned_allocator_adaptor<simple<int>,
+        boost::alignment::aligned_allocator_adaptor<A<int>,
             Alignment> a(5);
         int* p = a.allocate(1);
         BOOST_TEST(p != 0);
-        BOOST_TEST(boost::alignment::is_aligned(Alignment, p));
+        BOOST_TEST(boost::alignment::is_aligned(p, Alignment));
         std::memset(p, 0, 1);
         a.deallocate(p, 1);
     }
     {
-        boost::alignment::aligned_allocator_adaptor<simple<int>,
+        boost::alignment::aligned_allocator_adaptor<A<int>,
             Alignment> a(5);
         int* p1 = a.allocate(1);
         int* p2 = a.allocate(1, p1);
         BOOST_TEST(p2 != 0);
-        BOOST_TEST(boost::alignment::is_aligned(Alignment, p2));
+        BOOST_TEST(boost::alignment::is_aligned(p2, Alignment));
         std::memset(p2, 0, 1);
         a.deallocate(p2, 1);
         a.deallocate(p1, 1);
     }
     {
-        boost::alignment::aligned_allocator_adaptor<simple<int>,
+        boost::alignment::aligned_allocator_adaptor<A<int>,
             Alignment> a(5);
         int* p = a.allocate(0);
         a.deallocate(p, 0);
@@ -112,7 +100,7 @@ void test_allocate()
 template<std::size_t Alignment>
 void test_construct()
 {
-    boost::alignment::aligned_allocator_adaptor<simple<int>,
+    boost::alignment::aligned_allocator_adaptor<A<int>,
         Alignment> a(5);
     int* p = a.allocate(1);
     a.construct(p, 1);
@@ -125,15 +113,15 @@ template<std::size_t Alignment>
 void test_constructor()
 {
     {
-        boost::alignment::aligned_allocator_adaptor<simple<char>,
+        boost::alignment::aligned_allocator_adaptor<A<char>,
             Alignment> a1(5);
-        boost::alignment::aligned_allocator_adaptor<simple<int>,
+        boost::alignment::aligned_allocator_adaptor<A<int>,
             Alignment> a2(a1);
         BOOST_TEST(a2 == a1);
     }
     {
-        simple<int> a1(5);
-        boost::alignment::aligned_allocator_adaptor<simple<int>,
+        A<int> a1(5);
+        boost::alignment::aligned_allocator_adaptor<A<int>,
             Alignment> a2(a1);
         BOOST_TEST(a2.base() == a1);
     }
@@ -142,9 +130,9 @@ void test_constructor()
 template<std::size_t Alignment>
 void test_rebind()
 {
-    boost::alignment::aligned_allocator_adaptor<simple<int>,
+    boost::alignment::aligned_allocator_adaptor<A<int>,
         Alignment> a1(5);
-    typename boost::alignment::aligned_allocator_adaptor<simple<int>,
+    typename boost::alignment::aligned_allocator_adaptor<A<int>,
         Alignment>::template rebind<int>::other a2(a1);
     BOOST_TEST(a2 == a1);
 }
diff --git a/libs/align/test/aligned_allocator_test.cpp b/libs/align/test/aligned_allocator_test.cpp
index f0e7fb0b02..28651ddd40 100644
--- a/libs/align/test/aligned_allocator_test.cpp
+++ b/libs/align/test/aligned_allocator_test.cpp
@@ -9,7 +9,6 @@ http://boost.org/LICENSE_1_0.txt
 #include <boost/align/aligned_allocator.hpp>
 #include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <cstddef>
 #include <cstring>
 
 template<std::size_t Alignment>
@@ -19,7 +18,7 @@ void test_allocate()
         boost::alignment::aligned_allocator<int, Alignment> a;
         int* p = a.allocate(1);
         BOOST_TEST(p != 0);
-        BOOST_TEST(boost::alignment::is_aligned(Alignment, p));
+        BOOST_TEST(boost::alignment::is_aligned(p, Alignment));
         std::memset(p, 0, 1);
         a.deallocate(p, 1);
     }
diff --git a/libs/align/test/aligned_delete_test.cpp b/libs/align/test/aligned_delete_test.cpp
index b418bb8328..d7556a3b25 100644
--- a/libs/align/test/aligned_delete_test.cpp
+++ b/libs/align/test/aligned_delete_test.cpp
@@ -11,22 +11,18 @@ http://boost.org/LICENSE_1_0.txt
 #include <boost/align/alignment_of.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <new>
-#include <cstddef>
 
 template<class T>
 class type {
 public:
     static int count;
-
     type()
         : value() {
         count++;
     }
-
     ~type() {
         count--;
     }
-
 private:
     T value;
 };
diff --git a/libs/align/test/alignment_of_test.cpp b/libs/align/test/alignment_of_test.cpp
index 3f774b8347..386667974d 100644
--- a/libs/align/test/alignment_of_test.cpp
+++ b/libs/align/test/alignment_of_test.cpp
@@ -6,10 +6,9 @@ Distributed under the Boost Software
 License, Version 1.0.
 http://boost.org/LICENSE_1_0.txt
 */
-#include <boost/config.hpp>
 #include <boost/align/alignment_of.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <cstddef>
+#include <boost/config.hpp>
 
 #define OFFSET(t, m) ((std::size_t)(&((t*)0)->m))
 
@@ -207,11 +206,11 @@ void test_pointer()
 void test_member_pointer()
 {
     test<int X::*>();
-    test<int (X::*)()>();
+    test<int(X::*)()>();
 }
 
 enum E {
-    v = 1
+    V = 1
 };
 
 void test_enum()
diff --git a/libs/align/test/assume_aligned_test.cpp b/libs/align/test/assume_aligned_test.cpp
index caf741f65c..79fbf0d813 100644
--- a/libs/align/test/assume_aligned_test.cpp
+++ b/libs/align/test/assume_aligned_test.cpp
@@ -7,30 +7,56 @@ License, Version 1.0.
 http://boost.org/LICENSE_1_0.txt
 */
 #include <boost/align/assume_aligned.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/align/is_aligned.hpp>
-
-void test()
-{
-    char s[128];
-    char* p = s;
-    while (!boost::alignment::is_aligned(128, p)) {
-        p++;
-    }
-    void* q = p;
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 1);
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 2);
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 4);
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 8);
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 16);
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 32);
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 64);
-    BOOST_ALIGN_ASSUME_ALIGNED(q, 128);
-    BOOST_TEST(q == p);
+
+void* test1(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 1);
+    return p;
+}
+
+void* test2(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 2);
+    return p;
+}
+
+void* test4(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 4);
+    return p;
+}
+
+void* test8(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 8);
+    return p;
+}
+
+void* test16(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 16);
+    return p;
+}
+
+void* test32(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 32);
+    return p;
+}
+
+void* test64(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 64);
+    return p;
+}
+
+void* test128(void* p)
+{
+    BOOST_ALIGN_ASSUME_ALIGNED(p, 128);
+    return p;
 }
 
 int main()
 {
-    test();
-    return boost::report_errors();
+    return 0;
 }
diff --git a/libs/align/test/is_aligned_test.cpp b/libs/align/test/is_aligned_test.cpp
index eb38c3ec74..e9c5bad1d2 100644
--- a/libs/align/test/is_aligned_test.cpp
+++ b/libs/align/test/is_aligned_test.cpp
@@ -1,44 +1,80 @@
 /*
-(c) 2014 Glen Joseph Fernandes
+(c) 2014-2015 Glen Joseph Fernandes
 <glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
 License, Version 1.0.
 http://boost.org/LICENSE_1_0.txt
 */
+#include <boost/align/alignment_of.hpp>
 #include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <cstddef>
+#include <boost/config.hpp>
 
-template<std::size_t Alignment>
-void test()
-{
-    char s[Alignment << 1];
-    char* b = s;
-    while (!boost::alignment::is_aligned(Alignment, b)) {
-        b++;
-    }
-    std::size_t n = Alignment;
-    {
-        void* p = &b[n];
-        BOOST_TEST(boost::alignment::is_aligned(n, p));
+template<std::size_t N>
+struct A {
+};
+
+template<class T>
+struct P {
+    P()
+        : p(new T) {
     }
-    if (n > 1) {
-        void* p = &b[1];
-        BOOST_TEST(!boost::alignment::is_aligned(n, p));
+    ~P() {
+        delete p;
     }
+    T* p;
+};
+
+template<std::size_t N>
+void test(char* p, A<N>)
+{
+    BOOST_TEST(boost::alignment::is_aligned(p, N));
+    BOOST_TEST(!boost::alignment::is_aligned(&p[1], N));
+}
+
+void test(char* p, A<1>)
+{
+    BOOST_TEST(boost::alignment::is_aligned(p, 1));
 }
 
+template<class T>
+void test()
+{
+    P<T> o;
+    test(reinterpret_cast<char*>(o.p),
+        A<boost::alignment::alignment_of<T>::value>());
+}
+
+class X;
+
 int main()
 {
-    test<1>();
-    test<2>();
-    test<4>();
-    test<8>();
-    test<16>();
-    test<32>();
-    test<64>();
-    test<128>();
+    test<bool>();
+    test<char>();
+    test<wchar_t>();
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    test<char16_t>();
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    test<char32_t>();
+#endif
+    test<short>();
+    test<int>();
+    test<long>();
+#if !defined(BOOST_NO_LONG_LONG)
+    test<long long>();
+#endif
+    test<float>();
+    test<double>();
+    test<long double>();
+    test<void*>();
+    test<char*>();
+    test<int*>();
+    test<X*>();
+    test<void(*)()>();
+    test<int X::*>();
+    test<int(X::*)()>();
 
     return boost::report_errors();
 }