120 lines
3.6 KiB
Plaintext
120 lines
3.6 KiB
Plaintext
|
|
// (C) Copyright John Maddock 2000.
|
|
// Use, modification and distribution are subject to the Boost Software License,
|
|
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt).
|
|
//
|
|
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
|
|
|
|
#ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
|
|
#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
|
|
|
|
#include <boost/config.hpp>
|
|
#include <cstddef>
|
|
|
|
#include <boost/type_traits/intrinsics.hpp>
|
|
#include <boost/type_traits/integral_constant.hpp>
|
|
|
|
#ifdef BOOST_MSVC
|
|
# pragma warning(push)
|
|
# pragma warning(disable: 4121 4512) // alignment is sensitive to packing
|
|
#endif
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
|
|
#pragma option push -Vx- -Ve-
|
|
#endif
|
|
|
|
namespace boost {
|
|
|
|
template <typename T> struct alignment_of;
|
|
|
|
// get the alignment of some arbitrary type:
|
|
namespace detail {
|
|
|
|
#ifdef BOOST_MSVC
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4324) // structure was padded due to __declspec(align())
|
|
#endif
|
|
template <typename T>
|
|
struct alignment_of_hack
|
|
{
|
|
char c;
|
|
T t;
|
|
alignment_of_hack();
|
|
};
|
|
#ifdef BOOST_MSVC
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
template <unsigned A, unsigned S>
|
|
struct alignment_logic
|
|
{
|
|
BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S);
|
|
};
|
|
|
|
|
|
template< typename T >
|
|
struct alignment_of_impl
|
|
{
|
|
#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
|
|
//
|
|
// With MSVC both the native __alignof operator
|
|
// and our own logic gets things wrong from time to time :-(
|
|
// Using a combination of the two seems to make the most of a bad job:
|
|
//
|
|
BOOST_STATIC_CONSTANT(std::size_t, value =
|
|
(::boost::detail::alignment_logic<
|
|
sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
|
|
__alignof(T)
|
|
>::value));
|
|
#elif !defined(BOOST_ALIGNMENT_OF)
|
|
BOOST_STATIC_CONSTANT(std::size_t, value =
|
|
(::boost::detail::alignment_logic<
|
|
sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
|
|
sizeof(T)
|
|
>::value));
|
|
#else
|
|
//
|
|
// We put this here, rather than in the definition of
|
|
// alignment_of below, because MSVC's __alignof doesn't
|
|
// always work in that context for some unexplained reason.
|
|
// (See type_with_alignment tests for test cases).
|
|
//
|
|
BOOST_STATIC_CONSTANT(std::size_t, value = BOOST_ALIGNMENT_OF(T));
|
|
#endif
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
|
|
|
|
// references have to be treated specially, assume
|
|
// that a reference is just a special pointer:
|
|
template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
|
|
|
|
#ifdef __BORLANDC__
|
|
// long double gives an incorrect value of 10 (!)
|
|
// unless we do this...
|
|
struct long_double_wrapper{ long double ld; };
|
|
template<> struct alignment_of<long double> : public alignment_of<long_double_wrapper>{};
|
|
#endif
|
|
|
|
// void has to be treated specially:
|
|
template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
|
|
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
|
template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
|
|
template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
|
|
template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
|
|
#endif
|
|
|
|
} // namespace boost
|
|
|
|
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
|
|
#pragma option pop
|
|
#endif
|
|
#ifdef BOOST_MSVC
|
|
# pragma warning(pop)
|
|
#endif
|
|
|
|
#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
|
|
|