Citra-emu/ext-boost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update to 1.80.0

Browse Source
This commit is contained in:
emufan4568 2022-08-26 23:24:04 +03:00
parent c62b3c95df
commit 774b7328a2
1841 changed files with 213118 additions and 55929 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Jamroot
View File

@ -144,9 +144,12 @@ import option ;
import tools/boost\_install/boost-install ;
path-constant BOOST_ROOT : . ;
constant BOOST_VERSION : 1.71.0 ;
constant BOOST_VERSION : 1.80.0 ;
constant BOOST_JAMROOT_MODULE : $(__name__) ;
# Allow subprojects to simply `import config : requires ;` to get access to the requires rule
modules.poke : BOOST_BUILD_PATH : $(BOOST_ROOT)/libs/config/checks [ modules.peek : BOOST_BUILD_PATH ] ;
boostcpp.set-version $(BOOST_VERSION) ;
use-project /boost/architecture : libs/config/checks/architecture ;
@ -210,18 +213,15 @@ rule handle-static-runtime ( properties * )
# dangerous on Windows. Therefore, we disallow it. This might be drastic,
# but it was disabled for a while without anybody complaining.
# For CW, static runtime is needed so that std::locale works.
if <link>shared in $(properties) && <runtime-link>static in $(properties) &&
! ( <toolset>cw in $(properties) )
{
if ! $(.shared-static-warning-emitted)
{
ECHO "warning: skipping configuration link=shared, runtime-link=static" ;
ECHO "warning: this combination is either impossible or too dangerous" ;
ECHO "warning: to be of any use" ;
.shared-static-warning-emitted = 1 ;
}
local argv = [ modules.peek : ARGV ] ;
if <link>shared in $(properties)
&& <runtime-link>static in $(properties)
# For CW, static runtime is needed so that std::locale works.
&& ! ( <toolset>cw in $(properties) )
&& ! --allow-shared-static in $(argv)
{
boostcpp.emit-shared-static-warning ;
return <build>no ;
}
}

6
boost/algorithm/string/compare.hpp
View File

@ -65,7 +65,7 @@ namespace boost {
template< typename T1, typename T2 >
bool operator()( const T1& Arg1, const T2& Arg2 ) const
{
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
return std::toupper(Arg1)==std::toupper(Arg2);
#else
return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
@ -118,7 +118,7 @@ namespace boost {
template< typename T1, typename T2 >
bool operator()( const T1& Arg1, const T2& Arg2 ) const
{
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
return std::toupper(Arg1)<std::toupper(Arg2);
#else
return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
@ -171,7 +171,7 @@ namespace boost {
template< typename T1, typename T2 >
bool operator()( const T1& Arg1, const T2& Arg2 ) const
{
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
return std::toupper(Arg1)<=std::toupper(Arg2);
#else
return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);

7
boost/algorithm/string/detail/case_conv.hpp
View File

@ -15,6 +15,9 @@
#include <locale>
#include <functional>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/type_traits/make_unsigned.hpp>
namespace boost {
@ -40,7 +43,7 @@ namespace boost {
// Operation
CharT operator ()( CharT Ch ) const
{
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
#else
return std::tolower<CharT>( Ch, *m_Loc );
@ -62,7 +65,7 @@ namespace boost {
// Operation
CharT operator ()( CharT Ch ) const
{
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
#if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
#else
return std::toupper<CharT>( Ch, *m_Loc );

2
boost/algorithm/string/detail/find_format_all.hpp
View File

@ -18,6 +18,8 @@
#include <boost/algorithm/string/detail/find_format_store.hpp>
#include <boost/algorithm/string/detail/replace_storage.hpp>
#include <deque>
namespace boost {
namespace algorithm {
namespace detail {

30
boost/algorithm/string/detail/finder.hpp
View File

@ -13,7 +13,7 @@
#include <boost/algorithm/string/config.hpp>
#include <boost/algorithm/string/constants.hpp>
#include <boost/detail/iterator.hpp>
#include <iterator>
#include <boost/range/iterator_range_core.hpp>
#include <boost/range/begin.hpp>
@ -127,8 +127,8 @@ namespace boost {
if( boost::empty(m_Search) )
return result_type( End, End );
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<ForwardIteratorT>::iterator_category category;
typedef BOOST_STRING_TYPENAME
std::iterator_traits<ForwardIteratorT>::iterator_category category;
return findit( Begin, End, category() );
}
@ -344,9 +344,8 @@ namespace boost {
typedef iterator_range<ForwardIteratorT> result_type;
input_iterator_type It=Begin;
for(
unsigned int Index=0;
Index<N && It!=End; ++Index,++It ) {};
for( unsigned int Index=0; Index<N && It!=End; ++Index,++It )
;
return result_type( Begin, It );
}
@ -375,8 +374,8 @@ namespace boost {
ForwardIteratorT End,
unsigned int N )
{
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<ForwardIteratorT>::iterator_category category;
typedef BOOST_STRING_TYPENAME
std::iterator_traits<ForwardIteratorT>::iterator_category category;
return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
}
@ -397,10 +396,12 @@ namespace boost {
input_iterator_type It2=Begin;
// Advance It2 by N increments
for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
for( Index=0; Index<N && It2!=End; ++Index,++It2 )
;
// Advance It, It2 to the end
for(; It2!=End; ++It,++It2 ) {};
for(; It2!=End; ++It,++It2 )
;
return result_type( It, It2 );
}
@ -417,9 +418,8 @@ namespace boost {
typedef iterator_range<ForwardIteratorT> result_type;
input_iterator_type It=End;
for(
unsigned int Index=0;
Index<N && It!=Begin; ++Index,--It ) {};
for( unsigned int Index=0; Index<N && It!=Begin; ++Index,--It )
;
return result_type( It, End );
}
@ -448,8 +448,8 @@ namespace boost {
ForwardIteratorT End,
unsigned int N )
{
typedef BOOST_STRING_TYPENAME boost::detail::
iterator_traits<ForwardIteratorT>::iterator_category category;
typedef BOOST_STRING_TYPENAME
std::iterator_traits<ForwardIteratorT>::iterator_category category;
return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
}

2
boost/algorithm/string/detail/formatter.hpp
View File

@ -42,7 +42,7 @@ namespace boost {
m_Format(::boost::begin(Format), ::boost::end(Format)) {}
// Operation
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
template<typename Range2T>
result_type& operator()(const Range2T&)
{

1
boost/algorithm/string/find_format.hpp
View File

@ -12,7 +12,6 @@
#define BOOST_STRING_FIND_FORMAT_HPP
#include <deque>
#include <boost/detail/iterator.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>

1
boost/algorithm/string/formatter.hpp
View File

@ -11,7 +11,6 @@
#ifndef BOOST_STRING_FORMATTER_HPP
#define BOOST_STRING_FORMATTER_HPP
#include <boost/detail/iterator.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/range/as_literal.hpp>

19
boost/align/align.hpp Normal file
View File

@ -0,0 +1,19 @@
/*
Copyright 2014-2015 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_ALIGN_HPP
#define BOOST_ALIGN_ALIGN_HPP
#include <boost/config.hpp>
#if !defined(BOOST_NO_CXX11_STD_ALIGN) && !defined(BOOST_LIBSTDCXX_VERSION)
#include <boost/align/detail/align_cxx11.hpp>
#else
#include <boost/align/detail/align.hpp>
#endif
#endif

47
boost/align/aligned_alloc.hpp Normal file
View File

@ -0,0 +1,47 @@
/*
Copyright 2014-2015 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_ALIGNED_ALLOC_HPP
#define BOOST_ALIGN_ALIGNED_ALLOC_HPP
#include <boost/config.hpp>
#if defined(BOOST_HAS_UNISTD_H)
#include <unistd.h>
#endif
#if defined(__APPLE__) || defined(__APPLE_CC__) || defined(macintosh)
#include <AvailabilityMacros.h>
#endif
#if defined(BOOST_ALIGN_USE_ALIGN)
#include <boost/align/detail/aligned_alloc.hpp>
#elif defined(BOOST_ALIGN_USE_NEW)
#include <boost/align/detail/aligned_alloc_new.hpp>
#elif defined(_MSC_VER) && !defined(UNDER_CE)
#include <boost/align/detail/aligned_alloc_msvc.hpp>
#elif defined(__MINGW32__) && (__MSVCRT_VERSION__ >= 0x0700)
#include <boost/align/detail/aligned_alloc_msvc.hpp>
#elif defined(__MINGW32__)
#include <boost/align/detail/aligned_alloc_mingw.hpp>
#elif MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
#include <boost/align/detail/aligned_alloc_posix.hpp>
#elif MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
#include <boost/align/detail/aligned_alloc_macos.hpp>
#elif defined(__ANDROID__)
#include <boost/align/detail/aligned_alloc_android.hpp>
#elif defined(__SunOS_5_11) || defined(__SunOS_5_12)
#include <boost/align/detail/aligned_alloc_posix.hpp>
#elif defined(sun) || defined(__sun)
#include <boost/align/detail/aligned_alloc_sunos.hpp>
#elif (_POSIX_C_SOURCE >= 200112L) || (_XOPEN_SOURCE >= 600)
#include <boost/align/detail/aligned_alloc_posix.hpp>
#else
#include <boost/align/detail/aligned_alloc.hpp>
#endif
#endif

54
boost/align/alignment_of.hpp Normal file
View File

@ -0,0 +1,54 @@
/*
Copyright 2014-2016 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_ALIGNMENT_OF_HPP
#define BOOST_ALIGN_ALIGNMENT_OF_HPP
#include <boost/align/detail/element_type.hpp>
#include <boost/align/alignment_of_forward.hpp>
#if defined(_MSC_VER) && defined(__clang__)
#include <boost/align/detail/alignment_of_cxx11.hpp>
#elif defined(BOOST_MSVC)
#include <boost/align/detail/alignment_of_msvc.hpp>
#elif defined(__GNUC__) && defined(__unix__) && !defined(__LP64__)
#include <boost/align/detail/alignment_of.hpp>
#elif defined(BOOST_CLANG) && !defined(__x86_64__)
#include <boost/align/detail/alignment_of.hpp>
#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
#include <boost/align/detail/alignment_of_cxx11.hpp>
#elif defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
#include <boost/align/detail/alignment_of_gcc.hpp>
#elif defined(BOOST_CODEGEARC)
#include <boost/align/detail/alignment_of_codegear.hpp>
#elif defined(BOOST_CLANG)
#include <boost/align/detail/alignment_of_clang.hpp>
#elif __GNUC__ > 4
#include <boost/align/detail/alignment_of_gcc.hpp>
#elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)
#include <boost/align/detail/alignment_of_gcc.hpp>
#else
#include <boost/align/detail/alignment_of.hpp>
#endif
namespace boost {
namespace alignment {
template<class T>
struct alignment_of
: detail::alignment_of<typename
detail::element_type<T>::type>::type { };
#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
template<class T>
constexpr std::size_t alignment_of_v = alignment_of<T>::value;
#endif
} /* alignment */
} /* boost */
#endif

20
boost/align/alignment_of_forward.hpp Normal file
View File

@ -0,0 +1,20 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
#define BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
namespace boost {
namespace alignment {
template<class T>
struct alignment_of;
} /* alignment */
} /* boost */
#endif

38
boost/align/detail/align.hpp Normal file
View File

@ -0,0 +1,38 @@
/*
Copyright 2014-2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGN_HPP
#define BOOST_ALIGN_DETAIL_ALIGN_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/assert.hpp>
namespace boost {
namespace alignment {
inline void*
align(std::size_t alignment, std::size_t size, void*& ptr,
std::size_t& space)
{
BOOST_ASSERT(boost::alignment::detail::is_alignment(alignment));
if (size <= space) {
char* p = reinterpret_cast<char*>(~(alignment - 1) &
(reinterpret_cast<std::size_t>(ptr) + alignment - 1));
std::size_t n = p - static_cast<char*>(ptr);
if (n <= space - size) {
ptr = p;
space -= n;
return p;
}
}
return 0;
}
} /* alignment */
} /* boost */
#endif

21
boost/align/detail/align_cxx11.hpp Normal file
View File

@ -0,0 +1,21 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
#define BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
#include <memory>
namespace boost {
namespace alignment {
using std::align;
} /* alignment */
} /* boost */
#endif

52
boost/align/detail/aligned_alloc.hpp Normal file
View File

@ -0,0 +1,52 @@
/*
Copyright 2014-2015 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/align/align.hpp>
#include <boost/align/alignment_of.hpp>
#include <boost/assert.hpp>
#include <cstdlib>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
enum {
N = alignment_of<void*>::value
};
if (alignment < N) {
alignment = N;
}
std::size_t n = size + alignment - N;
void* p = std::malloc(sizeof(void*) + n);
if (p) {
void* r = static_cast<char*>(p) + sizeof(void*);
(void)boost::alignment::align(alignment, size, r, n);
*(static_cast<void**>(r) - 1) = p;
p = r;
}
return p;
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
if (ptr) {
std::free(*(static_cast<void**>(ptr) - 1));
}
}
} /* alignment */
} /* boost */
#endif

34
boost/align/detail/aligned_alloc_android.hpp Normal file
View File

@ -0,0 +1,34 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/assert.hpp>
#include <malloc.h>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
return ::memalign(alignment, size);
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
::free(ptr);
}
} /* alignment */
} /* boost */
#endif

44
boost/align/detail/aligned_alloc_macos.hpp Normal file
View File

@ -0,0 +1,44 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/assert.hpp>
#include <stdlib.h>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
if (size == 0) {
return 0;
}
if (alignment < sizeof(void*)) {
alignment = sizeof(void*);
}
void* p;
if (::posix_memalign(&p, alignment, size) != 0) {
p = 0;
}
return p;
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
::free(ptr);
}
} /* alignment */
} /* boost */
#endif

34
boost/align/detail/aligned_alloc_mingw.hpp Normal file
View File

@ -0,0 +1,34 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MINGW_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MINGW_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/assert.hpp>
#include <malloc.h>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
return ::__mingw_aligned_malloc(size, alignment);
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
::__mingw_aligned_free(ptr);
}
} /* alignment */
} /* boost */
#endif

34
boost/align/detail/aligned_alloc_msvc.hpp Normal file
View File

@ -0,0 +1,34 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/assert.hpp>
#include <malloc.h>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
return ::_aligned_malloc(size, alignment);
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
::_aligned_free(ptr);
}
} /* alignment */
} /* boost */
#endif

52
boost/align/detail/aligned_alloc_new.hpp Normal file
View File

@ -0,0 +1,52 @@
/*
Copyright 2014-2015 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_NEW_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_NEW_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/align/align.hpp>
#include <boost/align/alignment_of.hpp>
#include <boost/assert.hpp>
#include <new>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
enum {
N = alignment_of<void*>::value
};
if (alignment < N) {
alignment = N;
}
std::size_t n = size + alignment - N;
void* p = ::operator new(sizeof(void*) + n, std::nothrow);
if (p) {
void* r = static_cast<char*>(p) + sizeof(void*);
(void)boost::alignment::align(alignment, size, r, n);
*(static_cast<void**>(r) - 1) = p;
p = r;
}
return p;
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
if (ptr) {
::operator delete(*(static_cast<void**>(ptr) - 1));
}
}
} /* alignment */
} /* boost */
#endif

41
boost/align/detail/aligned_alloc_posix.hpp Normal file
View File

@ -0,0 +1,41 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/assert.hpp>
#include <stdlib.h>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
if (alignment < sizeof(void*)) {
alignment = sizeof(void*);
}
void* p;
if (::posix_memalign(&p, alignment, size) != 0) {
p = 0;
}
return p;
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
::free(ptr);
}
} /* alignment */
} /* boost */
#endif

34
boost/align/detail/aligned_alloc_sunos.hpp Normal file
View File

@ -0,0 +1,34 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP
#define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP
#include <boost/align/detail/is_alignment.hpp>
#include <boost/assert.hpp>
#include <stdlib.h>
namespace boost {
namespace alignment {
inline void*
aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
{
BOOST_ASSERT(detail::is_alignment(alignment));
return ::memalign(alignment, size);
}
inline void
aligned_free(void* ptr) BOOST_NOEXCEPT
{
::free(ptr);
}
} /* alignment */
} /* boost */
#endif

31
boost/align/detail/alignment_of.hpp Normal file
View File

@ -0,0 +1,31 @@
/*
Copyright 2014-2015 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
#include <boost/align/detail/min_size.hpp>
namespace boost {
namespace alignment {
namespace detail {
template<class T>
struct offset_value {
char value;
T object;
};
template<class T>
struct alignment_of
: min_size<sizeof(T), sizeof(offset_value<T>) - sizeof(T)> { };
} /* detail */
} /* alignment */
} /* boost */
#endif

26
boost/align/detail/alignment_of_clang.hpp Normal file
View File

@ -0,0 +1,26 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP
#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP
#include <boost/align/detail/integral_constant.hpp>
#include <cstddef>
namespace boost {
namespace alignment {
namespace detail {
template<class T>
struct alignment_of
: integral_constant<std::size_t, __alignof(T)> { };
} /* detail */
} /* alignment */
} /* boost */
#endif

26
boost/align/detail/alignment_of_codegear.hpp Normal file
View File

@ -0,0 +1,26 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP
#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP
#include <boost/align/detail/integral_constant.hpp>
#include <cstddef>
namespace boost {
namespace alignment {
namespace detail {
template<class T>
struct alignment_of
: integral_constant<std::size_t, alignof(T)> { };
} /* detail */
} /* alignment */
} /* boost */
#endif

23
boost/align/detail/alignment_of_cxx11.hpp Normal file
View File

@ -0,0 +1,23 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP
#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP
#include <type_traits>
namespace boost {
namespace alignment {
namespace detail {
using std::alignment_of;
} /* detail */
} /* alignment */
} /* boost */
#endif

26
boost/align/detail/alignment_of_gcc.hpp Normal file
View File

@ -0,0 +1,26 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP
#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP
#include <boost/align/detail/integral_constant.hpp>
#include <cstddef>
namespace boost {
namespace alignment {
namespace detail {
template<class T>
struct alignment_of
: integral_constant<std::size_t, __alignof__(T)> { };
} /* detail */
} /* alignment */
} /* boost */
#endif

32
boost/align/detail/alignment_of_msvc.hpp Normal file
View File

@ -0,0 +1,32 @@
/*
Copyright 2014-2015 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP
#define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP
#include <boost/align/detail/min_size.hpp>
namespace boost {
namespace alignment {
namespace detail {
template<class T>
struct offset_value {
T first;
char value;
T second;
};
template<class T>
struct alignment_of
: min_size<sizeof(T), sizeof(offset_value<T>) - (sizeof(T) << 1)> { };
} /* detail */
} /* alignment */
} /* boost */
#endif

91
boost/align/detail/element_type.hpp Normal file
View File

@ -0,0 +1,91 @@
/*
Copyright 2015 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_ELEMENT_TYPE_HPP
#define BOOST_ALIGN_DETAIL_ELEMENT_TYPE_HPP
#include <boost/config.hpp>
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
#include <type_traits>
#else
#include <cstddef>
#endif
namespace boost {
namespace alignment {
namespace detail {
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
using std::remove_reference;
using std::remove_all_extents;
using std::remove_cv;
#else
template<class T>
struct remove_reference {
typedef T type;
};
template<class T>
struct remove_reference<T&> {
typedef T type;
};
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template<class T>
struct remove_reference<T&&> {
typedef T type;
};
#endif
template<class T>
struct remove_all_extents {
typedef T type;
};
template<class T>
struct remove_all_extents<T[]> {
typedef typename remove_all_extents<T>::type type;
};
template<class T, std::size_t N>
struct remove_all_extents<T[N]> {
typedef typename remove_all_extents<T>::type type;
};
template<class T>
struct remove_cv {
typedef T type;
};
template<class T>
struct remove_cv<const T> {
typedef T type;
};
template<class T>
struct remove_cv<volatile T> {
typedef T type;
};
template<class T>
struct remove_cv<const volatile T> {
typedef T type;
};
#endif
template<class T>
struct element_type {
typedef typename remove_cv<typename remove_all_extents<typename
remove_reference<T>::type>::type>::type type;
};
} /* detail */
} /* alignment */
} /* boost */
#endif

53
boost/align/detail/integral_constant.hpp Normal file
View File

@ -0,0 +1,53 @@
/*
Copyright 2014-2016 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_INTEGRAL_CONSTANT_HPP
#define BOOST_ALIGN_DETAIL_INTEGRAL_CONSTANT_HPP
#include <boost/config.hpp>
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
#include <type_traits>
#endif
namespace boost {
namespace alignment {
namespace detail {
#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
using std::integral_constant;
using std::true_type;
using std::false_type;
#else
template<class T, T Value>
struct integral_constant {
typedef T value_type;
typedef integral_constant type;
BOOST_CONSTEXPR operator value_type() const BOOST_NOEXCEPT {
return Value;
}
BOOST_CONSTEXPR value_type operator()() const BOOST_NOEXCEPT {
return Value;
}
BOOST_STATIC_CONSTEXPR T value = Value;
};
template<class T, T Value>
BOOST_CONSTEXPR_OR_CONST T integral_constant<T, Value>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
#endif
} /* detail */
} /* alignment */
} /* boost */
#endif

28
boost/align/detail/is_alignment.hpp Normal file
View File

@ -0,0 +1,28 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
#define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
#include <boost/config.hpp>
#include <cstddef>
namespace boost {
namespace alignment {
namespace detail {
BOOST_CONSTEXPR inline bool
is_alignment(std::size_t value) BOOST_NOEXCEPT
{
return (value > 0) && ((value & (value - 1)) == 0);
}
} /* detail */
} /* alignment */
} /* boost */
#endif

26
boost/align/detail/min_size.hpp Normal file
View File

@ -0,0 +1,26 @@
/*
Copyright 2014 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_ALIGN_DETAIL_MIN_SIZE_HPP
#define BOOST_ALIGN_DETAIL_MIN_SIZE_HPP
#include <boost/align/detail/integral_constant.hpp>
#include <cstddef>
namespace boost {
namespace alignment {
namespace detail {
template<std::size_t A, std::size_t B>
struct min_size
: integral_constant<std::size_t, (A < B) ? A : B> { };
} /* detail */
} /* alignment */
} /* boost */
#endif

10
boost/archive/archive_exception.hpp
View File

@ -52,7 +52,7 @@ protected:
public:
typedef enum {
no_exception, // initialized without code
other_exception, // any excepton not listed below
other_exception, // any exception not listed below
unregistered_class, // attempt to serialize a pointer of
// an unregistered class
invalid_signature, // first line of archive does not contain
@ -63,7 +63,7 @@ public:
// serialize an object which has
// already been serialized through a pointer.
// Were this permitted, the archive load would result
// in the creation of an extra copy of the obect.
// in the creation of an extra copy of the object.
incompatible_native_format, // attempt to read native binary format
// on incompatible platform
array_size_too_short,// array being loaded doesn't fit in array allocated
@ -87,9 +87,9 @@ public:
const char * e1 = NULL,
const char * e2 = NULL
) BOOST_NOEXCEPT;
BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT;
BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
};
}// namespace archive

65
boost/archive/basic_archive.hpp
View File

@ -18,9 +18,9 @@
#include <cstring> // count
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/cstdint.hpp> // size_t
#include <boost/noncopyable.hpp>
#include <boost/integer_traits.hpp>
#include <boost/noncopyable.hpp>
#include <boost/serialization/library_version_type.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@ -33,52 +33,19 @@ namespace archive {
#pragma warning( disable : 4244 4267 )
#endif
/* NOTE : Warning : Warning : Warning : Warning : Warning
* Don't ever changes this. If you do, they previously created
* binary archives won't be readable !!!
*/
class library_version_type {
private:
typedef uint_least16_t base_type;
base_type t;
public:
library_version_type(): t(0) {};
explicit library_version_type(const unsigned int & t_) : t(t_){
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
library_version_type(const library_version_type & t_) :
t(t_.t)
{}
library_version_type & operator=(const library_version_type & rhs){
t = rhs.t;
return *this;
}
// used for text output
operator base_type () const {
return t;
}
// used for text input
operator base_type & (){
return t;
}
bool operator==(const library_version_type & rhs) const {
return t == rhs.t;
}
bool operator<(const library_version_type & rhs) const {
return t < rhs.t;
}
};
BOOST_ARCHIVE_DECL library_version_type
BOOST_ARCHIVE_DECL boost::serialization::library_version_type
BOOST_ARCHIVE_VERSION();
// create alias in boost::archive for older user code.
typedef boost::serialization::library_version_type library_version_type;
class version_type {
private:
typedef uint_least32_t base_type;
base_type t;
public:
// should be private - but MPI fails if it's not!!!
version_type(): t(0) {};
version_type(): t(0) {}
explicit version_type(const unsigned int & t_) : t(t_){
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
@ -111,7 +78,7 @@ private:
base_type t;
public:
// should be private - but then can't use BOOST_STRONG_TYPE below
class_id_type() : t(0) {};
class_id_type() : t(0) {}
explicit class_id_type(const int t_) : t(t_){
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
@ -142,18 +109,18 @@ public:
}
};
#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
#define BOOST_SERIALIZATION_NULL_POINTER_TAG boost::archive::class_id_type(-1)
class object_id_type {
private:
typedef uint_least32_t base_type;
base_type t;
public:
object_id_type(): t(0) {};
object_id_type(): t(0) {}
// note: presumes that size_t >= unsigned int.
// use explicit cast to silence useless warning
explicit object_id_type(const std::size_t & t_) : t(static_cast<base_type>(t_)){
// make quadriple sure that we haven't lost any real integer
// make quadruple sure that we haven't lost any real integer
// precision
BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
}
@ -188,16 +155,16 @@ struct tracking_type {
bool t;
explicit tracking_type(const bool t_ = false)
: t(t_)
{};
{}
tracking_type(const tracking_type & t_)
: t(t_.t)
{}
operator bool () const {
return t;
};
}
operator bool & () {
return t;
};
}
tracking_type & operator=(const bool t_){
t = t_;
return *this;
@ -279,7 +246,7 @@ BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
// set implementation level to primitive for all types
// used internally by the serialization library
BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::serialization::library_version_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
@ -294,7 +261,7 @@ BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
// set types used internally by the serialization library
// to be bitwise serializable
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::library_version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)

29
boost/archive/basic_binary_iarchive.hpp
View File

@ -30,6 +30,7 @@
#include <boost/archive/detail/common_iarchive.hpp>
#include <boost/serialization/collection_size_type.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/library_version_type.hpp>
#include <boost/serialization/item_version_type.hpp>
#include <boost/integer_traits.hpp>
@ -88,8 +89,8 @@ protected:
void load_override(class_id_optional_type & /* t */){}
void load_override(tracking_type & t, int /*version*/){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(6) < lvt){
boost::serialization::library_version_type lv = this->get_library_version();
if(boost::serialization::library_version_type(6) < lv){
int_least8_t x=0;
* this->This() >> x;
t = boost::archive::tracking_type(x);
@ -101,7 +102,7 @@ protected:
}
}
void load_override(class_id_type & t){
library_version_type lvt = this->get_library_version();
boost::serialization::library_version_type lv = this->get_library_version();
/*
* library versions:
* boost 1.39 -> 5
@ -120,7 +121,7 @@ protected:
*
* the fix here decodes class_id_type on 16bit for all v <= 7, which seems to be the correct behaviour ...
*/
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type (7) < lv){
this->detail_common_iarchive::load_override(t);
}
else{
@ -134,24 +135,24 @@ protected:
}
void load_override(version_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
boost::serialization::library_version_type lv = this->get_library_version();
if(boost::serialization::library_version_type(7) < lv){
this->detail_common_iarchive::load_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lv){
uint_least8_t x=0;
* this->This() >> x;
t = boost::archive::version_type(x);
}
else
if(boost::archive::library_version_type(5) < lvt){
if(boost::serialization::library_version_type(5) < lv){
uint_least16_t x=0;
* this->This() >> x;
t = boost::archive::version_type(x);
}
else
if(boost::archive::library_version_type(2) < lvt){
if(boost::serialization::library_version_type(2) < lv){
// upto 255 versions
unsigned char x=0;
* this->This() >> x;
@ -165,13 +166,13 @@ protected:
}
void load_override(boost::serialization::item_version_type & t){
library_version_type lvt = this->get_library_version();
// if(boost::archive::library_version_type(7) < lvt){
if(boost::archive::library_version_type(6) < lvt){
boost::serialization::library_version_type lv = this->get_library_version();
// if(boost::serialization::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(6) < lv){
this->detail_common_iarchive::load_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lv){
uint_least16_t x=0;
* this->This() >> x;
t = boost::serialization::item_version_type(x);
@ -184,7 +185,7 @@ protected:
}
void load_override(serialization::collection_size_type & t){
if(boost::archive::library_version_type(5) < this->get_library_version()){
if(boost::serialization::library_version_type(5) < this->get_library_version()){
this->detail_common_iarchive::load_override(t);
}
else{

1
boost/archive/basic_binary_iprimitive.hpp
View File

@ -48,7 +48,6 @@ namespace std{
#include <boost/integer.hpp>
#include <boost/integer_traits.hpp>
//#include <boost/mpl/placeholders.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
#include <boost/serialization/array_wrapper.hpp>

14
boost/archive/basic_binary_oarchive.hpp
View File

@ -97,11 +97,11 @@ protected:
#if 0
void save_override(const boost::archive::version_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lvt){
const boost::uint_least16_t x = t;
* this->This() << x;
}
@ -112,11 +112,11 @@ protected:
}
void save_override(const boost::serialization::item_version_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lvt){
const boost::uint_least16_t x = t;
* this->This() << x;
}
@ -128,11 +128,11 @@ protected:
void save_override(class_id_type & t){
library_version_type lvt = this->get_library_version();
if(boost::archive::library_version_type(7) < lvt){
if(boost::serialization::library_version_type(7) < lvt){
this->detail_common_oarchive::save_override(t);
}
else
if(boost::archive::library_version_type(6) < lvt){
if(boost::serialization::library_version_type(6) < lvt){
const boost::int_least16_t x = t;
* this->This() << x;
}
@ -155,7 +155,7 @@ protected:
#if 0
void save_override(const serialization::collection_size_type & t){
if (get_library_version() < boost::archive::library_version_type(6)){
if (get_library_version() < boost::serialization::library_version_type(6)){
unsigned int x=0;
* this->This() >> x;
t = serialization::collection_size_type(x);

1
boost/archive/basic_binary_oprimitive.hpp
View File

@ -43,7 +43,6 @@ namespace std{
#include <boost/scoped_ptr.hpp>
#include <boost/serialization/throw_exception.hpp>
//#include <boost/mpl/placeholders.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
#include <boost/serialization/array_wrapper.hpp>

6
boost/archive/basic_text_iarchive.hpp
View File

@ -54,7 +54,7 @@ public:
#else
protected:
#if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
// for some inexplicable reason insertion of "class" generates compile erro
// for some inexplicable reason insertion of "class" generates compile error
// on msvc 7.1
friend detail::interface_iarchive<Archive>;
#else
@ -76,12 +76,12 @@ protected:
load_override(class_name_type & t);
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
init(void);
init();
basic_text_iarchive(unsigned int flags) :
detail::common_iarchive<Archive>(flags)
{}
~basic_text_iarchive(){}
~basic_text_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

2
boost/archive/basic_text_oarchive.hpp
View File

@ -104,7 +104,7 @@ protected:
detail::common_oarchive<Archive>(flags),
delimiter(none)
{}
~basic_text_oarchive(){}
~basic_text_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

3
boost/archive/basic_text_oprimitive.hpp
View File

@ -154,10 +154,11 @@ protected:
template<class T>
void save_impl(const T &t, boost::mpl::bool_<true> &){
// must be a user mistake - can't serialize un-initialized data
if(os.fail())
if(os.fail()){
boost::serialization::throw_exception(
archive_exception(archive_exception::output_stream_error)
);
}
// The formulae for the number of decimla digits required is given in
// http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
// which is derived from Kahan's paper:

2
boost/archive/basic_xml_iarchive.hpp
View File

@ -104,7 +104,7 @@ protected:
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_xml_iarchive(unsigned int flags);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_xml_iarchive();
~basic_xml_iarchive() BOOST_OVERRIDE;
};
} // namespace archive

2
boost/archive/basic_xml_oarchive.hpp
View File

@ -123,7 +123,7 @@ protected:
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_xml_oarchive(unsigned int flags);
BOOST_ARCHIVE_OR_WARCHIVE_DECL
~basic_xml_oarchive();
~basic_xml_oarchive() BOOST_OVERRIDE;
};
} // namespace archive

8
boost/archive/binary_iarchive.hpp
View File

@ -42,12 +42,16 @@ public:
binary_iarchive_impl<
binary_iarchive, std::istream::char_type, std::istream::traits_type
>(is, flags)
{}
{
init(flags);
}
binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
binary_iarchive_impl<
binary_iarchive, std::istream::char_type, std::istream::traits_type
>(bsb, flags)
{}
{
init(flags);
}
};
} // namespace archive

8
boost/archive/binary_iarchive_impl.hpp
View File

@ -78,9 +78,7 @@ protected:
0 != (flags & no_codecvt)
),
basic_binary_iarchive<Archive>(flags)
{
init(flags);
}
{}
binary_iarchive_impl(
std::basic_istream<Elem, Tr> & is,
unsigned int flags
@ -90,9 +88,7 @@ protected:
0 != (flags & no_codecvt)
),
basic_binary_iarchive<Archive>(flags)
{
init(flags);
}
{}
};
} // namespace archive

8
boost/archive/binary_oarchive.hpp
View File

@ -42,12 +42,16 @@ public:
binary_oarchive_impl<
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
>(os, flags)
{}
{
init(flags);
}
binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
binary_oarchive_impl<
binary_oarchive, std::ostream::char_type, std::ostream::traits_type
>(bsb, flags)
{}
{
init(flags);
}
};
} // namespace archive

8
boost/archive/binary_oarchive_impl.hpp
View File

@ -79,9 +79,7 @@ protected:
0 != (flags & no_codecvt)
),
basic_binary_oarchive<Archive>(flags)
{
init(flags);
}
{}
binary_oarchive_impl(
std::basic_ostream<Elem, Tr> & os,
unsigned int flags
@ -91,9 +89,7 @@ protected:
0 != (flags & no_codecvt)
),
basic_binary_oarchive<Archive>(flags)
{
init(flags);
}
{}
};
} // namespace archive

36
boost/archive/codecvt_null.hpp
View File

@ -24,7 +24,7 @@
#include <boost/config.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
//#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std {
@ -52,21 +52,21 @@ class codecvt_null;
template<>
class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
{
virtual bool do_always_noconv() const throw() {
bool do_always_noconv() const throw() BOOST_OVERRIDE {
return true;
}
public:
explicit codecvt_null(std::size_t no_locale_manage = 0) :
std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
{}
virtual ~codecvt_null(){};
~codecvt_null() BOOST_OVERRIDE {}
};
template<>
class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
public std::codecvt<wchar_t, char, std::mbstate_t>
{
virtual std::codecvt_base::result
BOOST_SYMBOL_EXPORT std::codecvt_base::result
do_out(
std::mbstate_t & state,
const wchar_t * first1,
@ -75,8 +75,9 @@ class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
char * first2,
char * last2,
char * & next2
) const;
virtual std::codecvt_base::result
) const BOOST_OVERRIDE;
BOOST_SYMBOL_EXPORT std::codecvt_base::result
do_in(
std::mbstate_t & state,
const char * first1,
@ -85,18 +86,23 @@ class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
wchar_t * first2,
wchar_t * last2,
wchar_t * & next2
) const;
virtual int do_encoding( ) const throw( ){
) const BOOST_OVERRIDE;
BOOST_SYMBOL_EXPORT int do_encoding( ) const throw( ) BOOST_OVERRIDE {
return sizeof(wchar_t) / sizeof(char);
}
virtual int do_max_length( ) const throw( ){
BOOST_SYMBOL_EXPORT bool do_always_noconv() const throw() BOOST_OVERRIDE {
return false;
}
BOOST_SYMBOL_EXPORT int do_max_length( ) const throw( ) BOOST_OVERRIDE {
return do_encoding();
}
public:
explicit codecvt_null(std::size_t no_locale_manage = 0) :
std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
{}
//virtual ~codecvt_null(){};
BOOST_SYMBOL_EXPORT explicit codecvt_null(std::size_t no_locale_manage = 0);
BOOST_SYMBOL_EXPORT ~codecvt_null() BOOST_OVERRIDE ;
};
} // namespace archive
@ -105,6 +111,6 @@ public:
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
//#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP

4
boost/archive/detail/basic_iarchive.hpp
View File

@ -85,8 +85,8 @@ public:
);
// real public API starts here
BOOST_ARCHIVE_DECL void
set_library_version(library_version_type archive_library_version);
BOOST_ARCHIVE_DECL library_version_type
set_library_version(boost::serialization::library_version_type archive_library_version);
BOOST_ARCHIVE_DECL boost::serialization::library_version_type
get_library_version() const;
BOOST_ARCHIVE_DECL unsigned int
get_flags() const;

4
boost/archive/detail/basic_oarchive.hpp
View File

@ -77,11 +77,11 @@ public:
const basic_pointer_oserializer * bpos_ptr
);
void save_null_pointer(){
vsave(NULL_POINTER_TAG);
vsave(BOOST_SERIALIZATION_NULL_POINTER_TAG);
}
// real public interface starts here
BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
BOOST_ARCHIVE_DECL boost::serialization::library_version_type get_library_version() const;
BOOST_ARCHIVE_DECL unsigned int get_flags() const;
};

6
boost/archive/detail/check.hpp
View File

@ -4,12 +4,14 @@
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8

13
boost/archive/detail/common_iarchive.hpp
View File

@ -42,22 +42,22 @@ class BOOST_SYMBOL_VISIBLE common_iarchive :
friend class interface_iarchive<Archive>;
friend class basic_iarchive;
private:
virtual void vload(version_type & t){
void vload(version_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(object_id_type & t){
void vload(object_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_id_type & t){
void vload(class_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_id_optional_type & t){
void vload(class_id_optional_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(tracking_type & t){
void vload(tracking_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
virtual void vload(class_name_type &s){
void vload(class_name_type &s) BOOST_OVERRIDE {
* this->This() >> s;
}
protected:
@ -86,4 +86,3 @@ protected:
#endif
#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP

16
boost/archive/detail/common_oarchive.hpp
View File

@ -40,28 +40,28 @@ class BOOST_SYMBOL_VISIBLE common_oarchive :
friend class interface_oarchive<Archive>;
friend class basic_oarchive;
private:
virtual void vsave(const version_type t){
void vsave(const version_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const object_id_type t){
void vsave(const object_id_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const object_reference_type t){
void vsave(const object_reference_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_type t){
void vsave(const class_id_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_reference_type t){
void vsave(const class_id_reference_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_id_optional_type t){
void vsave(const class_id_optional_type t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const class_name_type & t){
void vsave(const class_name_type & t) BOOST_OVERRIDE {
* this->This() << t;
}
virtual void vsave(const tracking_type t){
void vsave(const tracking_type t) BOOST_OVERRIDE {
* this->This() << t;
}
protected:

2
boost/archive/detail/interface_iarchive.hpp
View File

@ -34,7 +34,7 @@ template<class Archive>
class interface_iarchive
{
protected:
interface_iarchive(){};
interface_iarchive() {}
public:
/////////////////////////////////////////////////////////
// archive public interface

2
boost/archive/detail/interface_oarchive.hpp
View File

@ -35,7 +35,7 @@ template<class Archive>
class interface_oarchive
{
protected:
interface_oarchive(){};
interface_oarchive() {}
public:
/////////////////////////////////////////////////////////
// archive public interface

44
boost/archive/detail/iserializer.hpp
View File

@ -2,14 +2,16 @@
#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
#if defined(BOOST_MSVC)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
@ -60,12 +62,12 @@ namespace std{
#if !defined(BOOST_MSVC) && \
(BOOST_WORKAROUND(__IBMCPP__, < 1210) || \
defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590))
#define DONT_USE_HAS_NEW_OPERATOR 1
#define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 1
#else
#define DONT_USE_HAS_NEW_OPERATOR 0
#define BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR 0
#endif
#if ! DONT_USE_HAS_NEW_OPERATOR
#if ! BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
#include <boost/type_traits/has_new_operator.hpp>
#endif
@ -120,7 +122,7 @@ template<class Archive, class T>
class iserializer : public basic_iserializer
{
private:
virtual void destroy(/*const*/ void *address) const {
void destroy(/*const*/ void *address) const BOOST_OVERRIDE {
boost::serialization::access::destroy(static_cast<T *>(address));
}
public:
@ -132,29 +134,29 @@ public:
>::get_const_instance()
)
{}
virtual BOOST_DLLEXPORT void load_object_data(
BOOST_DLLEXPORT void load_object_data(
basic_iarchive & ar,
void *x,
const unsigned int file_version
) const BOOST_USED;
virtual bool class_info() const {
) const BOOST_OVERRIDE BOOST_USED;
bool class_info() const BOOST_OVERRIDE {
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
virtual bool tracking(const unsigned int /* flags */) const {
bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
return boost::serialization::tracking_level< T >::value
== boost::serialization::track_always
|| ( boost::serialization::tracking_level< T >::value
== boost::serialization::track_selectively
&& serialized_as_pointer());
}
virtual version_type version() const {
version_type version() const BOOST_OVERRIDE {
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
bool is_polymorphic() const BOOST_OVERRIDE {
return boost::is_polymorphic< T >::value;
}
virtual ~iserializer(){};
~iserializer() BOOST_OVERRIDE {}
};
#ifdef BOOST_MSVC
@ -208,7 +210,7 @@ BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
template<class T>
struct heap_allocation {
// boost::has_new_operator< T > doesn't work on these compilers
#if DONT_USE_HAS_NEW_OPERATOR
#if BOOST_SERIALIZATION_DONT_USE_HAS_NEW_OPERATOR
// This doesn't handle operator new overload for class T
static T * invoke_new(){
return static_cast<T *>(operator new(sizeof(T)));
@ -289,26 +291,26 @@ class pointer_iserializer :
public basic_pointer_iserializer
{
private:
virtual void * heap_allocation() const {
void * heap_allocation() const BOOST_OVERRIDE {
detail::heap_allocation<T> h;
T * t = h.get();
h.release();
return t;
}
virtual const basic_iserializer & get_basic_serializer() const {
const basic_iserializer & get_basic_serializer() const BOOST_OVERRIDE {
return boost::serialization::singleton<
iserializer<Archive, T>
>::get_const_instance();
}
BOOST_DLLEXPORT virtual void load_object_ptr(
BOOST_DLLEXPORT void load_object_ptr(
basic_iarchive & ar,
void * x,
const unsigned int file_version
) const BOOST_USED;
) const BOOST_OVERRIDE BOOST_USED;
public:
// this should alway be a singleton so make the constructor protected
pointer_iserializer();
~pointer_iserializer();
~pointer_iserializer() BOOST_OVERRIDE;
};
#ifdef BOOST_MSVC
@ -573,7 +575,7 @@ struct load_array_type {
// convert integers to correct enum to load
// determine number of elements in the array. Consider the
// fact that some machines will align elements on boundries
// fact that some machines will align elements on boundaries
// other than characters.
std::size_t current_count = sizeof(t) / (
static_cast<char *>(static_cast<void *>(&t[1]))

28
boost/archive/detail/oserializer.hpp
View File

@ -4,12 +4,14 @@
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#pragma inline_depth(511)
#if !defined(__clang__)
#pragma inline_depth(255)
#pragma inline_recursion(on)
#endif
#endif
#if defined(__MWERKS__)
#pragma inline_depth(511)
#pragma inline_depth(255)
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
@ -116,26 +118,26 @@ public:
>::get_const_instance()
)
{}
virtual BOOST_DLLEXPORT void save_object_data(
BOOST_DLLEXPORT void save_object_data(
basic_oarchive & ar,
const void *x
) const BOOST_USED;
virtual bool class_info() const {
) const BOOST_OVERRIDE BOOST_USED;
bool class_info() const BOOST_OVERRIDE {
return boost::serialization::implementation_level< T >::value
>= boost::serialization::object_class_info;
}
virtual bool tracking(const unsigned int /* flags */) const {
bool tracking(const unsigned int /* flags */) const BOOST_OVERRIDE {
return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
|| (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
&& serialized_as_pointer());
}
virtual version_type version() const {
version_type version() const BOOST_OVERRIDE {
return version_type(::boost::serialization::version< T >::value);
}
virtual bool is_polymorphic() const {
bool is_polymorphic() const BOOST_OVERRIDE {
return boost::is_polymorphic< T >::value;
}
virtual ~oserializer(){}
~oserializer() BOOST_OVERRIDE {}
};
#ifdef BOOST_MSVC
@ -168,18 +170,18 @@ class pointer_oserializer :
{
private:
const basic_oserializer &
get_basic_serializer() const {
get_basic_serializer() const BOOST_OVERRIDE {
return boost::serialization::singleton<
oserializer<Archive, T>
>::get_const_instance();
}
virtual BOOST_DLLEXPORT void save_object_ptr(
BOOST_DLLEXPORT void save_object_ptr(
basic_oarchive & ar,
const void * x
) const BOOST_USED;
) const BOOST_OVERRIDE BOOST_USED;
public:
pointer_oserializer();
~pointer_oserializer();
~pointer_oserializer() BOOST_OVERRIDE;
};
#ifdef BOOST_MSVC

74
boost/archive/detail/polymorphic_iarchive_route.hpp
View File

@ -56,125 +56,125 @@ class polymorphic_iarchive_route :
{
private:
// these are used by the serialization library.
virtual void load_object(
void load_object(
void *t,
const basic_iserializer & bis
){
) BOOST_OVERRIDE {
ArchiveImplementation::load_object(t, bis);
}
virtual const basic_pointer_iserializer * load_pointer(
const basic_pointer_iserializer * load_pointer(
void * & t,
const basic_pointer_iserializer * bpis_ptr,
const basic_pointer_iserializer * (*finder)(
const boost::serialization::extended_type_info & type
)
){
) BOOST_OVERRIDE {
return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
}
virtual void set_library_version(library_version_type archive_library_version){
void set_library_version(boost::serialization::library_version_type archive_library_version) BOOST_OVERRIDE {
ArchiveImplementation::set_library_version(archive_library_version);
}
virtual library_version_type get_library_version() const{
boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {
return ArchiveImplementation::get_library_version();
}
virtual unsigned int get_flags() const {
unsigned int get_flags() const BOOST_OVERRIDE {
return ArchiveImplementation::get_flags();
}
virtual void delete_created_pointers(){
void delete_created_pointers() BOOST_OVERRIDE {
ArchiveImplementation::delete_created_pointers();
}
virtual void reset_object_address(
void reset_object_address(
const void * new_address,
const void * old_address
){
) BOOST_OVERRIDE {
ArchiveImplementation::reset_object_address(new_address, old_address);
}
virtual void load_binary(void * t, std::size_t size){
void load_binary(void * t, std::size_t size) BOOST_OVERRIDE {
ArchiveImplementation::load_binary(t, size);
}
// primitive types the only ones permitted by polymorphic archives
virtual void load(bool & t){
void load(bool & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(char & t){
void load(char & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(signed char & t){
void load(signed char & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned char & t){
void load(unsigned char & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#ifndef BOOST_NO_CWCHAR
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
virtual void load(wchar_t & t){
void load(wchar_t & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#endif
#endif
virtual void load(short & t){
void load(short & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned short & t){
void load(unsigned short & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(int & t){
void load(int & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned int & t){
void load(unsigned int & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(long & t){
void load(long & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned long & t){
void load(unsigned long & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#if defined(BOOST_HAS_LONG_LONG)
virtual void load(boost::long_long_type & t){
void load(boost::long_long_type & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(boost::ulong_long_type & t){
void load(boost::ulong_long_type & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#elif defined(BOOST_HAS_MS_INT64)
virtual void load(__int64 & t){
void load(__int64 & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(unsigned __int64 & t){
void load(unsigned __int64 & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#endif
virtual void load(float & t){
void load(float & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(double & t){
void load(double & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
virtual void load(std::string & t){
void load(std::string & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#ifndef BOOST_NO_STD_WSTRING
virtual void load(std::wstring & t){
void load(std::wstring & t) BOOST_OVERRIDE {
ArchiveImplementation::load(t);
}
#endif
// used for xml and other tagged formats default does nothing
virtual void load_start(const char * name){
void load_start(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::load_start(name);
}
virtual void load_end(const char * name){
void load_end(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::load_end(name);
}
virtual void register_basic_serializer(const basic_iserializer & bis){
void register_basic_serializer(const basic_iserializer & bis) BOOST_OVERRIDE {
ArchiveImplementation::register_basic_serializer(bis);
}
virtual helper_collection &
get_helper_collection(){
helper_collection &
get_helper_collection() BOOST_OVERRIDE {
return ArchiveImplementation::get_helper_collection();
}
public:
// this can't be inheriteded because they appear in mulitple
// this can't be inherited because they appear in multiple
// parents
typedef mpl::bool_<true> is_loading;
typedef mpl::bool_<false> is_saving;
@ -202,7 +202,7 @@ public:
) :
ArchiveImplementation(is, flags)
{}
virtual ~polymorphic_iarchive_route(){};
~polymorphic_iarchive_route() BOOST_OVERRIDE {}
};
} // namespace detail

70
boost/archive/detail/polymorphic_oarchive_route.hpp
View File

@ -56,116 +56,116 @@ class polymorphic_oarchive_route :
{
private:
// these are used by the serialization library.
virtual void save_object(
void save_object(
const void *x,
const detail::basic_oserializer & bos
){
) BOOST_OVERRIDE {
ArchiveImplementation::save_object(x, bos);
}
virtual void save_pointer(
void save_pointer(
const void * t,
const detail::basic_pointer_oserializer * bpos_ptr
){
) BOOST_OVERRIDE {
ArchiveImplementation::save_pointer(t, bpos_ptr);
}
virtual void save_null_pointer(){
void save_null_pointer() BOOST_OVERRIDE {
ArchiveImplementation::save_null_pointer();
}
// primitive types the only ones permitted by polymorphic archives
virtual void save(const bool t){
void save(const bool t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const char t){
void save(const char t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const signed char t){
void save(const signed char t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned char t){
void save(const unsigned char t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#ifndef BOOST_NO_CWCHAR
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
virtual void save(const wchar_t t){
void save(const wchar_t t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#endif
#endif
virtual void save(const short t){
void save(const short t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned short t){
void save(const unsigned short t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const int t){
void save(const int t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned int t){
void save(const unsigned int t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const long t){
void save(const long t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const unsigned long t){
void save(const unsigned long t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#if defined(BOOST_HAS_LONG_LONG)
virtual void save(const boost::long_long_type t){
void save(const boost::long_long_type t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const boost::ulong_long_type t){
void save(const boost::ulong_long_type t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#elif defined(BOOST_HAS_MS_INT64)
virtual void save(const boost::int64_t t){
void save(const boost::int64_t t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const boost::uint64_t t){
void save(const boost::uint64_t t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#endif
virtual void save(const float t){
void save(const float t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const double t){
void save(const double t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
virtual void save(const std::string & t){
void save(const std::string & t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#ifndef BOOST_NO_STD_WSTRING
virtual void save(const std::wstring & t){
void save(const std::wstring & t) BOOST_OVERRIDE {
ArchiveImplementation::save(t);
}
#endif
virtual library_version_type get_library_version() const{
boost::serialization::library_version_type get_library_version() const BOOST_OVERRIDE {
return ArchiveImplementation::get_library_version();
}
virtual unsigned int get_flags() const {
unsigned int get_flags() const BOOST_OVERRIDE {
return ArchiveImplementation::get_flags();
}
virtual void save_binary(const void * t, std::size_t size){
void save_binary(const void * t, std::size_t size) BOOST_OVERRIDE {
ArchiveImplementation::save_binary(t, size);
}
// used for xml and other tagged formats default does nothing
virtual void save_start(const char * name){
void save_start(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::save_start(name);
}
virtual void save_end(const char * name){
void save_end(const char * name) BOOST_OVERRIDE {
ArchiveImplementation::save_end(name);
}
virtual void end_preamble(){
void end_preamble() BOOST_OVERRIDE {
ArchiveImplementation::end_preamble();
}
virtual void register_basic_serializer(const detail::basic_oserializer & bos){
void register_basic_serializer(const detail::basic_oserializer & bos) BOOST_OVERRIDE {
ArchiveImplementation::register_basic_serializer(bos);
}
virtual helper_collection &
get_helper_collection(){
helper_collection &
get_helper_collection() BOOST_OVERRIDE {
return ArchiveImplementation::get_helper_collection();
}
public:
// this can't be inheriteded because they appear in mulitple
// this can't be inherited because they appear in multiple
// parents
typedef mpl::bool_<false> is_loading;
typedef mpl::bool_<true> is_saving;
@ -193,7 +193,7 @@ public:
) :
ArchiveImplementation(os, flags)
{}
virtual ~polymorphic_oarchive_route(){};
~polymorphic_oarchive_route() BOOST_OVERRIDE {}
};
} // namespace detail

1
boost/archive/detail/utf8_codecvt_facet.hpp
View File

@ -17,7 +17,6 @@
#include <boost/archive/detail/decl.hpp>
#define BOOST_UTF8_BEGIN_NAMESPACE \
namespace boost { namespace archive { namespace detail {
#define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
#define BOOST_UTF8_END_NAMESPACE }}}
#include <boost/detail/utf8_codecvt_facet.hpp>

2
boost/archive/dinkumware.hpp
View File

@ -127,8 +127,6 @@ operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
return is;
}
//#endif
template<>
class back_insert_iterator<basic_string<char> > : public
iterator<output_iterator_tag, char>

12
boost/archive/impl/basic_binary_iarchive.ipp
View File

@ -22,7 +22,7 @@ namespace std{
#endif
#include <boost/detail/workaround.hpp>
#include <boost/detail/endian.hpp>
#include <boost/predef/other/endian.h>
#include <boost/archive/basic_binary_iarchive.hpp>
@ -48,7 +48,7 @@ basic_binary_iarchive<Archive>::load_override(class_name_type & t){
template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
basic_binary_iarchive<Archive>::init(void){
basic_binary_iarchive<Archive>::init() {
// read signature in an archive version independent manner
std::string file_signature;
@ -84,12 +84,12 @@ basic_binary_iarchive<Archive>::init(void){
// make sure the version of the reading archive library can
// support the format of the archive being read
library_version_type input_library_version;
boost::serialization::library_version_type input_library_version;
//* this->This() >> input_library_version;
{
int v = 0;
v = this->This()->m_sb.sbumpc();
#if defined(BOOST_LITTLE_ENDIAN)
#if BOOST_ENDIAN_LITTLE_BYTE
if(v < 6){
;
}
@ -111,11 +111,11 @@ basic_binary_iarchive<Archive>::init(void){
// version 8+ followed by a zero
this->This()->m_sb.sbumpc();
}
#elif defined(BOOST_BIG_ENDIAN)
#elif BOOST_ENDIAN_BIG_BYTE
if(v == 0)
v = this->This()->m_sb.sbumpc();
#endif
input_library_version = static_cast<library_version_type>(v);
input_library_version = static_cast<boost::serialization::library_version_type>(v);
}
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))

2
boost/archive/impl/basic_binary_oarchive.ipp
View File

@ -34,7 +34,7 @@ basic_binary_oarchive<Archive>::init(){
const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
* this->This() << file_signature;
// write library version
const library_version_type v(BOOST_ARCHIVE_VERSION());
const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());
* this->This() << v;
}

4
boost/archive/impl/basic_text_iarchive.ipp
View File

@ -45,7 +45,7 @@ basic_text_iarchive<Archive>::load_override(class_name_type & t){
template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
basic_text_iarchive<Archive>::init(void){
basic_text_iarchive<Archive>::init() {
// read signature in an archive version independent manner
std::string file_signature;
* this->This() >> file_signature;
@ -56,7 +56,7 @@ basic_text_iarchive<Archive>::init(void){
// make sure the version of the reading archive library can
// support the format of the archive being read
library_version_type input_library_version;
boost::serialization::library_version_type input_library_version;
* this->This() >> input_library_version;
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))

3
boost/archive/impl/basic_text_iprimitive.ipp
View File

@ -112,8 +112,8 @@ basic_text_iprimitive<IStream>::basic_text_iprimitive(
) :
is(is_),
flags_saver(is_),
precision_saver(is_),
#ifndef BOOST_NO_STD_LOCALE
precision_saver(is_),
codecvt_null_facet(1),
archive_locale(is.getloc(), & codecvt_null_facet),
locale_saver(is)
@ -125,6 +125,7 @@ basic_text_iprimitive<IStream>::basic_text_iprimitive(
is_ >> std::noboolalpha;
}
#else
precision_saver(is_)
{}
#endif

2
boost/archive/impl/basic_text_oarchive.ipp
View File

@ -54,7 +54,7 @@ basic_text_oarchive<Archive>::init(){
const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
* this->This() << file_signature;
// write library version
const library_version_type v(BOOST_ARCHIVE_VERSION());
const boost::serialization::library_version_type v(BOOST_ARCHIVE_VERSION());
* this->This() << v;
}

8
boost/archive/impl/basic_text_oprimitive.ipp
View File

@ -10,7 +10,6 @@
#include <cstddef> // NULL
#include <algorithm> // std::copy
#include <exception> // std::uncaught_exception
#include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
@ -18,6 +17,8 @@ namespace std{
} // namespace std
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/archive/basic_text_oprimitive.hpp>
#include <boost/archive/iterators/base64_from_binary.hpp>
@ -86,8 +87,8 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
) :
os(os_),
flags_saver(os_),
precision_saver(os_),
#ifndef BOOST_NO_STD_LOCALE
precision_saver(os_),
codecvt_null_facet(1),
archive_locale(os.getloc(), & codecvt_null_facet),
locale_saver(os)
@ -99,6 +100,7 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
os_ << std::noboolalpha;
}
#else
precision_saver(os_)
{}
#endif
@ -106,7 +108,7 @@ basic_text_oprimitive<OStream>::basic_text_oprimitive(
template<class OStream>
BOOST_ARCHIVE_OR_WARCHIVE_DECL
basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
os << std::endl;
}

1
boost/archive/impl/basic_xml_iarchive.ipp
View File

@ -37,7 +37,6 @@ basic_xml_iarchive<Archive>::load_start(const char *name){
}
// don't check start tag at highest level
++depth;
return;
}
template<class Archive>

9
boost/archive/impl/text_iarchive_impl.ipp
View File

@ -115,14 +115,7 @@ text_iarchive_impl<Archive>::text_iarchive_impl(
0 != (flags & no_codecvt)
),
basic_text_iarchive<Archive>(flags)
{
if(0 == (flags & no_header))
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
this->init();
#else
this->basic_text_iarchive<Archive>::init();
#endif
}
{}
} // namespace archive
} // namespace boost

6
boost/archive/impl/text_oarchive_impl.ipp
View File

@ -93,12 +93,6 @@ text_oarchive_impl<Archive>::text_oarchive_impl(
),
basic_text_oarchive<Archive>(flags)
{
if(0 == (flags & no_header))
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
this->init();
#else
this->basic_text_oarchive<Archive>::init();
#endif
}
template<class Archive>

2
boost/archive/impl/text_wiarchive_impl.ipp
View File

@ -108,8 +108,6 @@ text_wiarchive_impl<Archive>::text_wiarchive_impl(
),
basic_text_iarchive<Archive>(flags)
{
if(0 == (flags & no_header))
basic_text_iarchive<Archive>::init();
}
} // archive

11
boost/archive/impl/xml_iarchive_impl.ipp
View File

@ -11,7 +11,6 @@
#include <boost/config.hpp>
#include <cstring> // memcpy
#include <cstddef> // NULL
#include <exception>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
@ -34,6 +33,7 @@ namespace std{
#include <boost/archive/dinkumware.hpp>
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/archive/xml_archive_exception.hpp>
@ -165,7 +165,7 @@ BOOST_ARCHIVE_DECL void
xml_iarchive_impl<Archive>::init(){
gimpl->init(is);
this->set_library_version(
library_version_type(gimpl->rv.version)
boost::serialization::library_version_type(gimpl->rv.version)
);
}
@ -181,15 +181,12 @@ xml_iarchive_impl<Archive>::xml_iarchive_impl(
),
basic_xml_iarchive<Archive>(flags),
gimpl(new xml_grammar())
{
if(0 == (flags & no_header))
init();
}
{}
template<class Archive>
BOOST_ARCHIVE_DECL
xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header)){
gimpl->windup(is);

9
boost/archive/impl/xml_oarchive_impl.ipp
View File

@ -10,7 +10,6 @@
#include <iomanip>
#include <algorithm> // std::copy
#include <string>
#include <exception>
#include <cstring> // strlen
#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
@ -20,6 +19,7 @@ namespace std{
} // namespace std
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/archive/iterators/xml_escape.hpp>
#include <boost/archive/iterators/ostream_iterator.hpp>
@ -109,10 +109,7 @@ xml_oarchive_impl<Archive>::xml_oarchive_impl(
0 != (flags & no_codecvt)
),
basic_xml_oarchive<Archive>(flags)
{
if(0 == (flags & no_header))
this->init();
}
{}
template<class Archive>
BOOST_ARCHIVE_DECL void
@ -132,7 +129,7 @@ xml_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
template<class Archive>
BOOST_ARCHIVE_DECL
xml_oarchive_impl<Archive>::~xml_oarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header))
this->windup();

8
boost/archive/impl/xml_wiarchive_impl.ipp
View File

@ -20,13 +20,13 @@ namespace std{
#include <boost/assert.hpp>
#include <algorithm> // std::copy
#include <exception> // uncaught exception
#include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
#include <boost/archive/dinkumware.hpp>
#endif
#include <boost/io/ios_state.hpp>
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/serialization/string.hpp>
@ -143,7 +143,7 @@ BOOST_WARCHIVE_DECL void
xml_wiarchive_impl<Archive>::init(){
gimpl->init(is);
this->set_library_version(
library_version_type(gimpl->rv.version)
boost::serialization::library_version_type(gimpl->rv.version)
);
}
@ -169,14 +169,12 @@ xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
is_.sync();
is_.imbue(archive_locale);
}
if(0 == (flags & no_header))
init();
}
template<class Archive>
BOOST_WARCHIVE_DECL
xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header)){
gimpl->windup(is);

7
boost/archive/impl/xml_woarchive_impl.ipp
View File

@ -13,7 +13,6 @@
#include <string>
#include <algorithm> // std::copy
#include <locale>
#include <exception>
#include <cstring> // strlen
#include <cstdlib> // mbtowc
@ -32,6 +31,8 @@ namespace std{
} // namespace std
#endif
#include <boost/core/uncaught_exceptions.hpp>
#include <boost/archive/xml_woarchive.hpp>
#include <boost/archive/detail/utf8_codecvt_facet.hpp>
@ -132,14 +133,12 @@ xml_woarchive_impl<Archive>::xml_woarchive_impl(
os_.flush();
os_.imbue(archive_locale);
}
if(0 == (flags & no_header))
this->init();
}
template<class Archive>
BOOST_WARCHIVE_DECL
xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
if(std::uncaught_exception())
if(boost::core::uncaught_exceptions() > 0)
return;
if(0 == (this->get_flags() & no_header)){
os << L"</boost_serialization>";

2
boost/archive/iterators/dataflow_exception.hpp
View File

@ -46,7 +46,7 @@ public:
dataflow_exception(exception_code c = other_exception) : code(c)
{}
virtual const char *what( ) const throw( )
const char *what( ) const throw( ) BOOST_OVERRIDE
{
const char *msg = "unknown exception code";
switch(code){

2
boost/archive/iterators/unescape.hpp
View File

@ -71,7 +71,7 @@ private:
++(this->base_reference());
dereference_impl();
m_full = false;
};
}
public:

4
boost/archive/iterators/wchar_from_mb.hpp
View File

@ -16,7 +16,6 @@
// See http://www.boost.org for updates, documentation, and revision history.
#include <boost/assert.hpp>
#include <cctype>
#include <cstddef> // size_t
#ifndef BOOST_NO_CWCHAR
@ -30,6 +29,8 @@ namespace std{
using ::mbstate_t;
} // namespace std
#endif
#include <boost/assert.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/array.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/archive/detail/utf8_codecvt_facet.hpp>
@ -165,6 +166,7 @@ void wchar_from_mb<Base>::drain(){
const typename boost::iterators::iterator_value<Base>::type * input_new_start;
typename iterator_value<this_t>::type * next_available;
BOOST_ATTRIBUTE_UNUSED // redundant with ignore_unused below but clarifies intention
std::codecvt_base::result r = m_codecvt_facet.in(
m_mbs,
m_input.m_buffer.begin(),

3
boost/archive/polymorphic_binary_iarchive.hpp
View File

@ -35,7 +35,7 @@ public:
polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<binary_iarchive>(is, flags)
{}
~polymorphic_binary_iarchive(){}
~polymorphic_binary_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP

3
boost/archive/polymorphic_binary_oarchive.hpp
View File

@ -30,7 +30,7 @@ public:
polymorphic_binary_oarchive(std::ostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<binary_oarchive>(os, flags)
{}
~polymorphic_binary_oarchive(){}
~polymorphic_binary_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -42,4 +42,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP

11
boost/archive/polymorphic_iarchive.hpp
View File

@ -31,6 +31,7 @@ namespace std{
#include <boost/archive/detail/iserializer.hpp>
#include <boost/archive/detail/interface_iarchive.hpp>
#include <boost/serialization/library_version_type.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/archive/detail/register_archive.hpp>
@ -116,11 +117,13 @@ public:
load_end(t.name());
}
protected:
virtual ~polymorphic_iarchive_impl(){};
virtual ~polymorphic_iarchive_impl() {}
public:
// utility function implemented by all legal archives
virtual void set_library_version(library_version_type archive_library_version) = 0;
virtual library_version_type get_library_version() const = 0;
virtual void set_library_version(
boost::serialization::library_version_type archive_library_version
) = 0;
virtual boost::serialization::library_version_type get_library_version() const = 0;
virtual unsigned int get_flags() const = 0;
virtual void delete_created_pointers() = 0;
virtual void reset_object_address(
@ -156,7 +159,7 @@ class BOOST_SYMBOL_VISIBLE polymorphic_iarchive :
public polymorphic_iarchive_impl
{
public:
virtual ~polymorphic_iarchive(){};
~polymorphic_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

6
boost/archive/polymorphic_oarchive.hpp
View File

@ -118,11 +118,11 @@ public:
save_end(t.name());
}
protected:
virtual ~polymorphic_oarchive_impl(){};
virtual ~polymorphic_oarchive_impl() {}
public:
// utility functions implemented by all legal archives
virtual unsigned int get_flags() const = 0;
virtual library_version_type get_library_version() const = 0;
virtual boost::serialization::library_version_type get_library_version() const = 0;
virtual void save_binary(const void * t, std::size_t size) = 0;
virtual void save_object(
@ -140,7 +140,7 @@ class BOOST_SYMBOL_VISIBLE polymorphic_oarchive :
public polymorphic_oarchive_impl
{
public:
virtual ~polymorphic_oarchive(){};
~polymorphic_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

3
boost/archive/polymorphic_text_iarchive.hpp
View File

@ -35,7 +35,7 @@ public:
polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<text_iarchive>(is, flags)
{}
~polymorphic_text_iarchive(){}
~polymorphic_text_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP

3
boost/archive/polymorphic_text_oarchive.hpp
View File

@ -30,7 +30,7 @@ public:
polymorphic_text_oarchive(std::ostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<text_oarchive>(os, flags)
{}
~polymorphic_text_oarchive(){}
~polymorphic_text_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -42,4 +42,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP

3
boost/archive/polymorphic_text_wiarchive.hpp
View File

@ -39,7 +39,7 @@ public:
polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<text_wiarchive>(is, flags)
{}
~polymorphic_text_wiarchive(){}
~polymorphic_text_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -56,4 +56,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP

3
boost/archive/polymorphic_text_woarchive.hpp
View File

@ -34,7 +34,7 @@ public:
polymorphic_text_woarchive(std::wostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<text_woarchive>(os, flags)
{}
~polymorphic_text_woarchive(){}
~polymorphic_text_woarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -47,4 +47,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP

3
boost/archive/polymorphic_xml_iarchive.hpp
View File

@ -35,7 +35,7 @@ public:
polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<xml_iarchive>(is, flags)
{}
~polymorphic_xml_iarchive(){}
~polymorphic_xml_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -51,4 +51,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP

3
boost/archive/polymorphic_xml_oarchive.hpp
View File

@ -30,7 +30,7 @@ public:
polymorphic_xml_oarchive(std::ostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<xml_oarchive>(os, flags)
{}
~polymorphic_xml_oarchive(){}
~polymorphic_xml_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive
} // namespace boost
@ -41,4 +41,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
)
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP

3
boost/archive/polymorphic_xml_wiarchive.hpp
View File

@ -34,7 +34,7 @@ public:
polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
detail::polymorphic_iarchive_route<xml_wiarchive>(is, flags)
{}
~polymorphic_xml_wiarchive(){}
~polymorphic_xml_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -47,4 +47,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP

3
boost/archive/polymorphic_xml_woarchive.hpp
View File

@ -34,7 +34,7 @@ public:
polymorphic_xml_woarchive(std::wostream & os, unsigned int flags = 0) :
detail::polymorphic_oarchive_route<xml_woarchive>(os, flags)
{}
~polymorphic_xml_woarchive(){}
~polymorphic_xml_woarchive() BOOST_OVERRIDE {}
};
} // namespace archive
@ -47,4 +47,3 @@ BOOST_SERIALIZATION_REGISTER_ARCHIVE(
#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP

9
boost/archive/text_iarchive.hpp
View File

@ -89,7 +89,7 @@ protected:
text_iarchive_impl(std::istream & is, unsigned int flags);
// don't import inline definitions! leave this as a reminder.
//BOOST_ARCHIVE_DECL
~text_iarchive_impl(){};
~text_iarchive_impl() BOOST_OVERRIDE {}
};
} // namespace archive
@ -115,8 +115,11 @@ public:
text_iarchive(std::istream & is_, unsigned int flags = 0) :
// note: added _ to suppress useless gcc warning
text_iarchive_impl<text_iarchive>(is_, flags)
{}
~text_iarchive(){}
{
if(0 == (flags & no_header))
init();
}
~text_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

11
boost/archive/text_oarchive.hpp
View File

@ -86,14 +86,14 @@ protected:
text_oarchive_impl(std::ostream & os, unsigned int flags);
// don't import inline definitions! leave this as a reminder.
//BOOST_ARCHIVE_DECL
~text_oarchive_impl(){};
~text_oarchive_impl() BOOST_OVERRIDE {}
public:
BOOST_ARCHIVE_DECL void
save_binary(const void *address, std::size_t count);
};
// do not derive from this class. If you want to extend this functionality
// via inhertance, derived from text_oarchive_impl instead. This will
// via inheritance, derived from text_oarchive_impl instead. This will
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE text_oarchive :
public text_oarchive_impl<text_oarchive>
@ -102,8 +102,11 @@ public:
text_oarchive(std::ostream & os_, unsigned int flags = 0) :
// note: added _ to suppress useless gcc warning
text_oarchive_impl<text_oarchive>(os_, flags)
{}
~text_oarchive(){}
{
if(0 == (flags & no_header))
init();
}
~text_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

9
boost/archive/text_wiarchive.hpp
View File

@ -94,7 +94,7 @@ protected:
}
BOOST_WARCHIVE_DECL
text_wiarchive_impl(std::wistream & is, unsigned int flags);
~text_wiarchive_impl(){};
~text_wiarchive_impl() BOOST_OVERRIDE {}
};
} // namespace archive
@ -119,8 +119,11 @@ class BOOST_SYMBOL_VISIBLE text_wiarchive :
public:
text_wiarchive(std::wistream & is, unsigned int flags = 0) :
text_wiarchive_impl<text_wiarchive>(is, flags)
{}
~text_wiarchive(){}
{
if(0 == (flags & no_header))
init();
}
~text_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive

14
boost/archive/text_woarchive.hpp
View File

@ -101,10 +101,7 @@ protected:
0 != (flags & no_codecvt)
),
basic_text_oarchive<Archive>(flags)
{
if(0 == (flags & no_header))
basic_text_oarchive<Archive>::init();
}
{}
public:
void save_binary(const void *address, std::size_t count){
put(static_cast<wchar_t>('\n'));
@ -127,7 +124,7 @@ public:
// typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive;
// do not derive from this class. If you want to extend this functionality
// via inhertance, derived from text_oarchive_impl instead. This will
// via inheritance, derived from text_oarchive_impl instead. This will
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE text_woarchive :
public text_woarchive_impl<text_woarchive>
@ -135,8 +132,11 @@ class BOOST_SYMBOL_VISIBLE text_woarchive :
public:
text_woarchive(std::wostream & os, unsigned int flags = 0) :
text_woarchive_impl<text_woarchive>(os, flags)
{}
~text_woarchive(){}
{
if(0 == (flags & no_header))
init();
}
~text_woarchive() BOOST_OVERRIDE {}
};
} // namespace archive

4
boost/archive/xml_archive_exception.hpp
View File

@ -45,8 +45,8 @@ public:
const char * e1 = NULL,
const char * e2 = NULL
);
BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &);
BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE;
};
}// namespace archive

9
boost/archive/xml_iarchive.hpp
View File

@ -101,7 +101,7 @@ protected:
BOOST_ARCHIVE_DECL
xml_iarchive_impl(std::istream & is, unsigned int flags);
BOOST_ARCHIVE_DECL
~xml_iarchive_impl();
~xml_iarchive_impl() BOOST_OVERRIDE;
};
} // namespace archive
@ -125,8 +125,11 @@ class BOOST_SYMBOL_VISIBLE xml_iarchive :
public:
xml_iarchive(std::istream & is, unsigned int flags = 0) :
xml_iarchive_impl<xml_iarchive>(is, flags)
{}
~xml_iarchive(){};
{
if(0 == (flags & no_header))
init();
}
~xml_iarchive() BOOST_OVERRIDE {}
};
} // namespace archive

11
boost/archive/xml_oarchive.hpp
View File

@ -86,7 +86,7 @@ protected:
BOOST_ARCHIVE_DECL
xml_oarchive_impl(std::ostream & os, unsigned int flags);
BOOST_ARCHIVE_DECL
~xml_oarchive_impl();
~xml_oarchive_impl() BOOST_OVERRIDE;
public:
BOOST_ARCHIVE_DECL
void save_binary(const void *address, std::size_t count);
@ -112,7 +112,7 @@ namespace archive {
// typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive;
// do not derive from this class. If you want to extend this functionality
// via inhertance, derived from xml_oarchive_impl instead. This will
// via inheritance, derived from xml_oarchive_impl instead. This will
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE xml_oarchive :
public xml_oarchive_impl<xml_oarchive>
@ -120,8 +120,11 @@ class BOOST_SYMBOL_VISIBLE xml_oarchive :
public:
xml_oarchive(std::ostream & os, unsigned int flags = 0) :
xml_oarchive_impl<xml_oarchive>(os, flags)
{}
~xml_oarchive(){}
{
if(0 == (flags & no_header))
init();
}
~xml_oarchive() BOOST_OVERRIDE {}
};
} // namespace archive

12
boost/archive/xml_wiarchive.hpp
View File

@ -29,7 +29,6 @@
#include <boost/archive/basic_xml_iarchive.hpp>
#include <boost/archive/detail/register_archive.hpp>
#include <boost/serialization/item_version_type.hpp>
// #include <boost/archive/detail/utf8_codecvt_facet.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@ -105,9 +104,9 @@ protected:
BOOST_WARCHIVE_DECL void
init();
BOOST_WARCHIVE_DECL
xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
xml_wiarchive_impl(std::wistream & is, unsigned int flags);
BOOST_WARCHIVE_DECL
~xml_wiarchive_impl();
~xml_wiarchive_impl() BOOST_OVERRIDE;
};
} // namespace archive
@ -132,8 +131,11 @@ class BOOST_SYMBOL_VISIBLE xml_wiarchive :
public:
xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
xml_wiarchive_impl<xml_wiarchive>(is, flags)
{}
~xml_wiarchive(){}
{
if(0 == (flags & no_header))
init();
}
~xml_wiarchive() BOOST_OVERRIDE {}
};
} // namespace archive

13
boost/archive/xml_woarchive.hpp
View File

@ -29,13 +29,11 @@ namespace std{
#include <ostream>
//#include <boost/smart_ptr/scoped_ptr.hpp>
#include <boost/archive/detail/auto_link_warchive.hpp>
#include <boost/archive/basic_text_oprimitive.hpp>
#include <boost/archive/basic_xml_oarchive.hpp>
#include <boost/archive/detail/register_archive.hpp>
#include <boost/serialization/item_version_type.hpp>
//#include <boost/archive/detail/utf8_codecvt_facet.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
@ -95,7 +93,7 @@ protected:
BOOST_WARCHIVE_DECL
xml_woarchive_impl(std::wostream & os, unsigned int flags);
BOOST_WARCHIVE_DECL
~xml_woarchive_impl();
~xml_woarchive_impl() BOOST_OVERRIDE;
public:
BOOST_WARCHIVE_DECL void
save_binary(const void *address, std::size_t count);
@ -106,7 +104,7 @@ public:
// typedef xml_woarchive_impl<xml_woarchive_impl<...> > xml_woarchive;
// do not derive from this class. If you want to extend this functionality
// via inhertance, derived from xml_woarchive_impl instead. This will
// via inheritance, derived from xml_woarchive_impl instead. This will
// preserve correct static polymorphism.
class BOOST_SYMBOL_VISIBLE xml_woarchive :
public xml_woarchive_impl<xml_woarchive>
@ -114,8 +112,11 @@ class BOOST_SYMBOL_VISIBLE xml_woarchive :
public:
xml_woarchive(std::wostream & os, unsigned int flags = 0) :
xml_woarchive_impl<xml_woarchive>(os, flags)
{}
~xml_woarchive(){}
{
if(0 == (flags & no_header))
init();
}
~xml_woarchive() BOOST_OVERRIDE {}
};
} // namespace archive

3
boost/array.hpp
View File

@ -41,13 +41,12 @@
#endif
#include <cstddef>
#include <iterator>
#include <stdexcept>
#include <boost/assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/swap.hpp>
// Handles broken standard libraries better than <iterator>
#include <boost/detail/iterator.hpp>
#include <boost/throw_exception.hpp>
#include <algorithm>

Some files were not shown because too many files have changed in this diff Show More