Initial alignment_of preview

Author: glenfe

doc/Jamfile.v2

@@ -10,7 +10,6 @@ import quickbook ;
 
 doxygen reference
   :
-    [ glob ../../../boost/align.hpp ]
     [ glob ../../../boost/align/*.hpp ]
   :
     <doxygen:param>ENABLE_PREPROCESSING=YES

doc/align.qbk

@@ -42,6 +42,10 @@ It provides a deleter, class `aligned_delete`, which
 makes use of `aligned_free`. It is suitable for use
 with constructed objects allocated with `aligned_alloc`.
 
+It provides class template `alignment_of` for
+implementations which do not have the C++11 standard
+library `std::alignment_of` class template available.
+
 It also provides function `is_aligned` to test the
 alignment of a pointer.
 
@@ -75,6 +79,11 @@ The `aligned_delete` class can be used in place of the
 default deleter, `std::default_delete`, to destroy and
 free any objects allocated with `aligned_alloc`.
 
+The `alignment_of` class template can be used to
+determine alignment of a type and is provided for
+standard library implementations which do not yet provide
+`std::alignment_of`.
+
 The `is_aligned` function can be used for verification
 or to branch to a faster code path which requires
 that objects have a specified extended alignment.
@@ -279,6 +288,27 @@ std::unique_ptr<T,
 
 [endsect]
 
+[section Using alignment_of]
+
+We want to assert, at compile time, that the alignment
+of a type, `T`, is at least as large as the alignment of
+a second type, `U`.
+
+``
+#include <boost/align/alignment_of.hpp>
+``
+
+Use the `alignment_of` class template to determine the
+alignment of the type.
+
+``
+static_assert(boost::alignment::alignment_of<T>::
+    value >= boost::alignment::alignment_of<U>::
+    value, "");
+``
+
+[endsect]
+
 [section Using is_aligned]
 
 We want to assert that the alignment of a pointer, `p`,

example/aligned_ptr.hpp

@@ -19,12 +19,12 @@
  allocated with `aligned_alloc`.
 */
 
-#include <boost/align.hpp>
+#include <boost/align/aligned_delete.hpp>
 #include <memory>
 
 template<class T>
 using aligned_ptr = std::unique_ptr<T,
-    boost::aligned_delete>;
+    boost::alignment::aligned_delete>;
 //]
 
 #endif

example/aligned_vector.hpp

@@ -19,12 +19,12 @@
  to specify an minimum extended alignment
  when used with any type.
 */
-#include <boost/align.hpp>
+#include <boost/align/aligned_allocator.hpp>
 #include <vector>
 
 template<class T, std::size_t Alignment = 1>
 using aligned_vector = std::vector<T,
-    boost::aligned_allocator<T, Alignment> >;
+    boost::alignment::aligned_allocator<T, Alignment> >;
 //]
 
 #endif

example/make_aligned.hpp

@@ -26,17 +26,16 @@ template<class T, class... Args>
 inline aligned_ptr<T>
     make_aligned(Args&&... args)
 {
-    auto p = boost::aligned_alloc(alignof(T),
+    auto p = boost::alignment::aligned_alloc(alignof(T),
         sizeof(T));
     if (!p) {
         throw std::bad_alloc();
     }
     try {
-        auto q = ::new(p)
-            T(std::forward<Args>(args)...);
+        auto q = ::new(p) T(std::forward<Args>(args)...);
         return aligned_ptr<T>(q);
     } catch (...) {
-        boost::aligned_free(p);
+        boost::alignment::aligned_free(p);
         throw;
     }
 }

include/boost/align.hpp

@@ -21,8 +21,8 @@
 #include <boost/throw_exception.hpp>
 #include <boost/align/aligned_alloc.hpp>
 #include <boost/align/aligned_allocator_forward.hpp>
+#include <boost/align/alignment_of.hpp>
 #include <boost/align/detail/addressof.hpp>
-#include <boost/align/detail/alignment_of.hpp>
 #include <boost/align/detail/is_alignment_const.hpp>
 #include <boost/align/detail/max_align.hpp>
 #include <boost/align/detail/max_count_of.hpp>
@@ -87,8 +87,7 @@ namespace boost {
 
         private:
             enum {
-                TypeAlign = detail::
-                    alignment_of<value_type>::value,
+                TypeAlign = alignment_of<value_type>::value,
 
                 MaxAlign = detail::
                     max_align<Alignment, TypeAlign>::value

include/boost/align/aligned_allocator.hpp

@@ -20,8 +20,8 @@
 #include <boost/static_assert.hpp>
 #include <boost/align/align.hpp>
 #include <boost/align/aligned_allocator_adaptor_forward.hpp>
+#include <boost/align/alignment_of.hpp>
 #include <boost/align/detail/addressof.hpp>
-#include <boost/align/detail/alignment_of.hpp>
 #include <boost/align/detail/is_alignment_const.hpp>
 #include <boost/align/detail/max_align.hpp>
 #include <new>
@@ -104,11 +104,9 @@ namespace boost {
 
         private:
             enum {
-                TypeAlign = detail::
-                    alignment_of<value_type>::value,
+                TypeAlign = alignment_of<value_type>::value,
 
-                PtrAlign = detail::
-                    alignment_of<CharPtr>::value,
+                PtrAlign = alignment_of<CharPtr>::value,
 
                 BlockAlign = detail::
                     max_align<PtrAlign, TypeAlign>::value,

include/boost/align/aligned_allocator_adaptor.hpp

@@ -0,0 +1,61 @@
+/*
+ Copyright (c) 2014 Glen Joseph Fernandes
+ glenfe at live dot com
+
+ Distributed under the Boost Software License,
+ Version 1.0. (See accompanying file LICENSE_1_0.txt
+ or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGNMENT_OF_HPP
+#define BOOST_ALIGN_ALIGNMENT_OF_HPP
+
+/**
+ Class template alignment_of.
+
+ @file
+ @author Glen Fernandes
+*/
+
+#include <boost/config.hpp>
+
+/**
+ @cond
+*/
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#include <boost/align/detail/alignment_of_cxx11.hpp>
+#elif BOOST_MSVC >= 1400
+#include <boost/align/detail/alignment_of_msvc.hpp>
+#elif defined(BOOST_CLANG)
+#include <boost/align/detail/alignment_of_clang.hpp>
+#elif (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR >= 3))
+#include <boost/align/detail/alignment_of_gcc.hpp>
+#elif defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
+#include <boost/align/detail/alignment_of_gcc.hpp>
+#elif defined(_CODEGEARC__)
+#include <boost/align/detail/alignment_of_codegear.hpp>
+#else
+#include <boost/align/detail/alignment_of.hpp>
+#endif
+/**
+ @endcond
+*/
+
+/**
+ Boost namespace.
+*/
+namespace boost {
+    /**
+     Alignment namespace.
+    */
+    namespace alignment {
+        /**
+         Class template alignment_of.
+
+         @remark Value: `alignof(T)`.
+        */
+        template<class T>
+        struct alignment_of;
+    }
+}
+
+#endif

include/boost/align/alignment_of.hpp

@@ -9,23 +9,25 @@
 #ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
 
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-#include <type_traits>
-#else
-#include <boost/type_traits/alignment_of.hpp>
-#endif
+#include <boost/align/detail/min_size.hpp>
 
 namespace boost {
     namespace alignment {
         namespace detail {
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-            using std::alignment_of;
-#else
-            using boost::alignment_of;
-#endif
+            template<class T>
+            struct padded {
+                char unit;
+                T object;
+            };
         }
+
+        template<class T>
+        struct alignment_of {
+            enum {
+                value = detail::min_size<sizeof(T),
+                    sizeof(detail::padded<T>) - sizeof(T)>::value
+            };
+        };
     }
 }