You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
169 lines
5.5 KiB
169 lines
5.5 KiB
#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP |
|
#define BOOST_ARCHIVE_DETAIL_CHECK_HPP |
|
|
|
// MS compatible compilers support #pragma once |
|
#if defined(_MSC_VER) && (_MSC_VER >= 1020) |
|
# pragma once |
|
#pragma inline_depth(511) |
|
#pragma inline_recursion(on) |
|
#endif |
|
|
|
#if defined(__MWERKS__) |
|
#pragma inline_depth(511) |
|
#endif |
|
|
|
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 |
|
// check.hpp: interface for serialization system. |
|
|
|
// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . |
|
// Use, modification and distribution is subject to the Boost Software |
|
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
|
// http://www.boost.org/LICENSE_1_0.txt) |
|
|
|
// See http://www.boost.org for updates, documentation, and revision history. |
|
|
|
#include <boost/config.hpp> |
|
|
|
#include <boost/static_assert.hpp> |
|
#include <boost/type_traits/is_const.hpp> |
|
|
|
#include <boost/mpl/eval_if.hpp> |
|
#include <boost/mpl/or.hpp> |
|
#include <boost/mpl/equal_to.hpp> |
|
#include <boost/mpl/int.hpp> |
|
#include <boost/mpl/not.hpp> |
|
#include <boost/mpl/greater.hpp> |
|
#include <boost/mpl/assert.hpp> |
|
|
|
#include <boost/serialization/static_warning.hpp> |
|
#include <boost/serialization/version.hpp> |
|
#include <boost/serialization/level.hpp> |
|
#include <boost/serialization/tracking.hpp> |
|
#include <boost/serialization/wrapper.hpp> |
|
|
|
namespace boost { |
|
namespace archive { |
|
namespace detail { |
|
|
|
// checks for objects |
|
|
|
template<class T> |
|
inline void check_object_level(){ |
|
typedef |
|
BOOST_DEDUCED_TYPENAME mpl::greater_equal< |
|
serialization::implementation_level< T >, |
|
mpl::int_<serialization::primitive_type> |
|
>::type typex; |
|
|
|
// trap attempts to serialize objects marked |
|
// not_serializable |
|
BOOST_STATIC_ASSERT(typex::value); |
|
} |
|
|
|
template<class T> |
|
inline void check_object_versioning(){ |
|
typedef |
|
BOOST_DEDUCED_TYPENAME mpl::or_< |
|
BOOST_DEDUCED_TYPENAME mpl::greater< |
|
serialization::implementation_level< T >, |
|
mpl::int_<serialization::object_serializable> |
|
>, |
|
BOOST_DEDUCED_TYPENAME mpl::equal_to< |
|
serialization::version< T >, |
|
mpl::int_<0> |
|
> |
|
> typex; |
|
// trap attempts to serialize with objects that don't |
|
// save class information in the archive with versioning. |
|
BOOST_STATIC_ASSERT(typex::value); |
|
} |
|
|
|
template<class T> |
|
inline void check_object_tracking(){ |
|
// presume it has already been determined that |
|
// T is not a const |
|
BOOST_STATIC_ASSERT(! boost::is_const< T >::value); |
|
typedef BOOST_DEDUCED_TYPENAME mpl::equal_to< |
|
serialization::tracking_level< T >, |
|
mpl::int_<serialization::track_never> |
|
>::type typex; |
|
// saving an non-const object of a type not marked "track_never) |
|
|
|
// may be an indicator of an error usage of the |
|
// serialization library and should be double checked. |
|
// See documentation on object tracking. Also, see the |
|
// "rationale" section of the documenation |
|
// for motivation for this checking. |
|
|
|
BOOST_STATIC_WARNING(typex::value); |
|
} |
|
|
|
// checks for pointers |
|
|
|
template<class T> |
|
inline void check_pointer_level(){ |
|
// we should only invoke this once we KNOW that T |
|
// has been used as a pointer!! |
|
typedef |
|
BOOST_DEDUCED_TYPENAME mpl::or_< |
|
BOOST_DEDUCED_TYPENAME mpl::greater< |
|
serialization::implementation_level< T >, |
|
mpl::int_<serialization::object_serializable> |
|
>, |
|
BOOST_DEDUCED_TYPENAME mpl::not_< |
|
BOOST_DEDUCED_TYPENAME mpl::equal_to< |
|
serialization::tracking_level< T >, |
|
mpl::int_<serialization::track_selectively> |
|
> |
|
> |
|
> typex; |
|
// Address the following when serializing to a pointer: |
|
|
|
// a) This type doesn't save class information in the |
|
// archive. That is, the serialization trait implementation |
|
// level <= object_serializable. |
|
// b) Tracking for this type is set to "track selectively" |
|
|
|
// in this case, indication that an object is tracked is |
|
// not stored in the archive itself - see level == object_serializable |
|
// but rather the existence of the operation ar >> T * is used to |
|
// infer that an object of this type should be tracked. So, if |
|
// you save via a pointer but don't load via a pointer the operation |
|
// will fail on load without given any valid reason for the failure. |
|
|
|
// So if your program traps here, consider changing the |
|
// tracking or implementation level traits - or not |
|
// serializing via a pointer. |
|
BOOST_STATIC_WARNING(typex::value); |
|
} |
|
|
|
template<class T> |
|
void inline check_pointer_tracking(){ |
|
typedef BOOST_DEDUCED_TYPENAME mpl::greater< |
|
serialization::tracking_level< T >, |
|
mpl::int_<serialization::track_never> |
|
>::type typex; |
|
// serializing an object of a type marked "track_never" through a pointer |
|
// could result in creating more objects than were saved! |
|
BOOST_STATIC_WARNING(typex::value); |
|
} |
|
|
|
template<class T> |
|
inline void check_const_loading(){ |
|
typedef |
|
BOOST_DEDUCED_TYPENAME mpl::or_< |
|
BOOST_DEDUCED_TYPENAME boost::serialization::is_wrapper< T >, |
|
BOOST_DEDUCED_TYPENAME mpl::not_< |
|
BOOST_DEDUCED_TYPENAME boost::is_const< T > |
|
> |
|
>::type typex; |
|
// cannot load data into a "const" object unless it's a |
|
// wrapper around some other non-const object. |
|
BOOST_STATIC_ASSERT(typex::value); |
|
} |
|
|
|
} // detail |
|
} // archive |
|
} // boost |
|
|
|
#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
|
|
|