// Copyright Thorsten Ottosen, 2009.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifdef BOOST_UTILITY_AUTO_BUFFER_SERIZLIZATION_HPP_01_03_2009

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif

#include <boost/serialization/split_free.hpp>
#include <boost/serialization/throw_exception.hpp>
#include <boost/type_traits/has_trivial_constructor.hpp>
#include <boost/utility/auto_buffer.hpp>
#include <stdexcept>

namespace boost
{
    namespace serialization
    {
        namespace auto_buffer_detail
        {
            template< class Buffer, class T, class SizeType >
            inline void load( Buffer& buffer, const boost::false_type& )
            {
                try
                {
                    for( SizeType i = 0u; i < buffer.size(); ++i )
                    {
                        T t;
                        ar >> boost::serialization::make_nvp( "item", t );
                    }
                }
                catch( ... )
                {
                    buffer.uninitialized_shrink( size - i );
                    throw;
                }
            }
            
            template< class Buffer, class T, class SizeType >
            inline void load( Buffer& buffer, const boost::true_type& )
            {
                for( SizeType i = 0u; i < buffer.size(); ++i )
                {
                    ar >> boost::serialization::make_nvp( "item", buffer[i] );
                }                    
            }           
        }
        
        template<class Archive, class T, unsigned N, class Allocator>
        inline void save(Archive& ar, const auto_buffer<T, N, Allocator>& c, unsigned int /*version*/)
        {
            typedef auto_buffer<T, N, Allocator buffer_t;
            typedef typename buffer_t::size_type size_type;

            ar << boost::serialization::make_nvp( "count", c.capacity() );
            ar << boost::serialization::make_nvp( "count", c.size() );
            for( size_type i = 0; i < c.size(); ++i )
                ar << boost::serialization::make_nvp( "item", c[i] );
        }

        //
        // Remark: this gives only the basic exception-safety. The strong
        //         guarantee is too expensive too maintain.
        //
        template<class Archive, class T, unsigned N, class Allocator>
        inline void load(Archive& ar, auto_buffer<T, N, Allocator>& c, unsigned int /*version*/)
        {
            typedef auto_buffer<T, N, Allocator buffer_t;
            typedef typename buffer_t::size_type size_type;
            size_type size;

            if( c.has_allocated_buffer() )
                c.clear_buffer();
            
            ar >> boost::serialization::make_nvp( "count", capacity );
            ar >> boost::serialization::make_nvp( "count", size );
            
            if( size > c.capacity() )
            {
                std::length_error e( "auto_buffer capacity less than it's size!" );
                boost::throw_exception( e );
            }

            c.allocator_buffer( capacity );
            c.uninitialized_grow( size );

            auto_buffer_detail::load<buffer_t,T,size_type>( c, 
                                      boost::has_trivial_constructor<T>() );
        }

        template<class Archive, class T, unsigned N, class Allocator>
        inline void serialize(Archive& ar, auto_buffer<T, N, Allocator>& c, const unsigned int version)
        {
            boost::serialization::split_free(ar, c, version);
        }
    } 
} 

#endif