// (C) Copyright 2002-2008, Fernando Luis Cacciola Carballal. // // Distributed under 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) // // 21 Ago 2002 (Created) Fernando Cacciola // 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker // 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola // 21 Ago 2008 (Added swap) Niels Dekker, Fernando Cacciola // 20 Feb 2009 (Fixed logical const-ness issues) Niels Dekker, Fernando Cacciola // 03 Apr 2010 (Added initialized<T>, suggested by Jeffrey Hellrung, fixing #3472) Niels Dekker // 30 May 2010 (Made memset call conditional, fixing #3869) Niels Dekker // #ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP #define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP // Note: The implementation of boost::value_initialized had to deal with the // fact that various compilers haven't fully implemented value-initialization. // The constructor of boost::value_initialized<T> works around these compiler // issues, by clearing the bytes of T, before constructing the T object it // contains. More details on these issues are at libs/utility/value_init.htm #include <boost/aligned_storage.hpp> #include <boost/config.hpp> // For BOOST_NO_COMPLETE_VALUE_INITIALIZATION. #include <boost/detail/workaround.hpp> #include <boost/static_assert.hpp> #include <boost/type_traits/cv_traits.hpp> #include <boost/type_traits/alignment_of.hpp> #include <boost/swap.hpp> #include <cstring> #include <new> #ifdef BOOST_MSVC #pragma warning(push) #if _MSC_VER >= 1310 // It is safe to ignore the following warning from MSVC 7.1 or higher: // "warning C4351: new behavior: elements of array will be default initialized" #pragma warning(disable: 4351) // It is safe to ignore the following MSVC warning, which may pop up when T is // a const type: "warning C4512: assignment operator could not be generated". #pragma warning(disable: 4512) #endif #endif #ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED // suggests that a workaround should be applied, because of compiler issues // regarding value-initialization. #define BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED #endif // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND // switches the value-initialization workaround either on or off. #ifndef BOOST_DETAIL_VALUE_INIT_WORKAROUND #ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 1 #else #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0 #endif #endif namespace boost { template<class T> class initialized { private : struct wrapper { #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) typename #endif remove_const<T>::type data; wrapper() : data() { } wrapper(T const & arg) : data(arg) { } }; mutable #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) typename #endif aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x; wrapper * wrapper_address() const { return static_cast<wrapper *>( static_cast<void*>(&x)); } public : initialized() { #if BOOST_DETAIL_VALUE_INIT_WORKAROUND std::memset(&x, 0, sizeof(x)); #endif new (wrapper_address()) wrapper(); } initialized(initialized const & arg) { new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address()))); } explicit initialized(T const & arg) { new (wrapper_address()) wrapper(arg); } initialized & operator=(initialized const & arg) { // Assignment is only allowed when T is non-const. BOOST_STATIC_ASSERT( ! is_const<T>::value ); *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address())); return *this; } ~initialized() { wrapper_address()->wrapper::~wrapper(); } T const & data() const { return wrapper_address()->data; } T& data() { return wrapper_address()->data; } void swap(initialized & arg) { ::boost::swap( this->data(), arg.data() ); } operator T const &() const { return wrapper_address()->data; } operator T&() { return wrapper_address()->data; } } ; template<class T> T const& get ( initialized<T> const& x ) { return x.data() ; } template<class T> T& get ( initialized<T>& x ) { return x.data() ; } template<class T> void swap ( initialized<T> & lhs, initialized<T> & rhs ) { lhs.swap(rhs) ; } template<class T> class value_initialized { private : // initialized<T> does value-initialization by default. initialized<T> m_data; public : value_initialized() : m_data() { } T const & data() const { return m_data.data(); } T& data() { return m_data.data(); } void swap(value_initialized & arg) { m_data.swap(arg.m_data); } operator T const &() const { return m_data; } operator T&() { return m_data; } } ; template<class T> T const& get ( value_initialized<T> const& x ) { return x.data() ; } template<class T> T& get ( value_initialized<T>& x ) { return x.data() ; } template<class T> void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs ) { lhs.swap(rhs) ; } class initialized_value_t { public : template <class T> operator T() const { return initialized<T>().data(); } }; initialized_value_t const initialized_value = {} ; } // namespace boost #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif