| #ifndef BOOST_SERIALIZATION_ARRAY_HPP |
| #define BOOST_SERIALIZATION_ARRAY_HPP |
| |
| // (C) Copyright 2005 Matthias Troyer and Dave Abrahams |
| // 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) |
| |
| #include <iostream> |
| #include <cstddef> // std::size_t |
| #include <cstddef> |
| #include <boost/config.hpp> // msvc 6.0 needs this for warning suppression |
| #if defined(BOOST_NO_STDC_NAMESPACE) |
| namespace std{ |
| using ::size_t; |
| } // namespace std |
| #endif |
| |
| #include <boost/serialization/nvp.hpp> |
| #include <boost/serialization/split_member.hpp> |
| #include <boost/serialization/wrapper.hpp> |
| #include <boost/mpl/always.hpp> |
| #include <boost/mpl/apply.hpp> |
| #include <boost/mpl/bool.hpp> |
| #include <boost/type_traits/remove_const.hpp> |
| #include <boost/array.hpp> |
| |
| namespace boost { namespace serialization { |
| |
| // traits to specify whether to use an optimized array serialization |
| |
| #ifdef __BORLANDC__ |
| // workaround for Borland compiler |
| template <class Archive> |
| struct use_array_optimization { |
| template <class T> struct apply : boost::mpl::false_ {}; |
| }; |
| |
| #else |
| template <class Archive> |
| struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {}; |
| #endif |
| |
| template<class T> |
| class array : |
| public wrapper_traits<const array< T > > |
| { |
| public: |
| typedef T value_type; |
| |
| array(value_type* t, std::size_t s) : |
| m_t(t), |
| m_element_count(s) |
| {} |
| array(const array & rhs) : |
| m_t(rhs.m_t), |
| m_element_count(rhs.m_element_count) |
| {} |
| array & operator=(const array & rhs){ |
| m_t = rhs.m_t; |
| m_element_count = rhs.m_element_count; |
| } |
| |
| // default implementation |
| template<class Archive> |
| void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const |
| { |
| // default implemention does the loop |
| std::size_t c = count(); |
| value_type * t = address(); |
| while(0 < c--) |
| ar & boost::serialization::make_nvp("item", *t++); |
| } |
| |
| // optimized implementation |
| template<class Archive> |
| void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ ) |
| { |
| boost::serialization::split_member(ar, *this, version); |
| } |
| |
| // default implementation |
| template<class Archive> |
| void save(Archive &ar, const unsigned int version) const |
| { |
| ar.save_array(*this,version); |
| } |
| |
| // default implementation |
| template<class Archive> |
| void load(Archive &ar, const unsigned int version) |
| { |
| ar.load_array(*this,version); |
| } |
| |
| // default implementation |
| template<class Archive> |
| void serialize(Archive &ar, const unsigned int version) |
| { |
| typedef BOOST_DEDUCED_TYPENAME |
| boost::serialization::use_array_optimization<Archive>::template apply< |
| BOOST_DEDUCED_TYPENAME remove_const< T >::type |
| >::type use_optimized; |
| serialize_optimized(ar,version,use_optimized()); |
| } |
| |
| value_type* address() const |
| { |
| return m_t; |
| } |
| |
| std::size_t count() const |
| { |
| return m_element_count; |
| } |
| |
| private: |
| value_type* m_t; |
| std::size_t m_element_count; |
| }; |
| |
| template<class T> |
| inline |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING |
| const |
| #endif |
| array< T > make_array( T* t, std::size_t s){ |
| return array< T >(t, s); |
| } |
| |
| template <class Archive, class T, std::size_t N> |
| void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int /* version */) |
| { |
| ar & boost::serialization::make_nvp("elems",a.elems); |
| } |
| |
| } } // end namespace boost::serialization |
| |
| #ifdef __BORLANDC__ |
| // ignore optimizations for Borland |
| #define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive) |
| #else |
| #define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive) \ |
| namespace boost { namespace serialization { \ |
| template <> struct use_array_optimization<Archive> { \ |
| template <class ValueType> \ |
| struct apply : boost::mpl::apply1<Archive::use_array_optimization \ |
| , BOOST_DEDUCED_TYPENAME boost::remove_const<ValueType>::type \ |
| >::type {}; \ |
| }; }} |
| #endif // __BORLANDC__ |
| |
| #endif //BOOST_SERIALIZATION_ARRAY_HPP |