//

// Boost.Pointer Container

//

//  Copyright Thorsten Ottosen 2003-2005. 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)

//

// For more information, see http://www.boost.org/libs/ptr_container/

//

#ifndef BOOST_PTR_CONTAINER_PTR_ARRAY_HPP

#define BOOST_PTR_CONTAINER_PTR_ARRAY_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)

# pragma once

#endif

#include <boost/array.hpp>

#include <boost/static_assert.hpp>

#include <boost/ptr_container/ptr_sequence_adapter.hpp>

namespace boost

{

    namespace ptr_container_detail

    {

        template

        <

            class T,

            size_t N,

            class Allocator = int // dummy

        >

        class ptr_array_impl : public boost::array<T,N>

        {

        public:

            typedef Allocator allocator_type;

            ptr_array_impl( Allocator a = Allocator() )

            {

                this->assign( 0 );

            }

            ptr_array_impl( size_t, T*, Allocator a = Allocator() )

            {

                this->assign( 0 );

            }

        };

    }

    template

    <

        class T,

        size_t N,

        class CloneAllocator = heap_clone_allocator

    >

    class ptr_array : public

        ptr_sequence_adapter< T,

                              ptr_container_detail::ptr_array_impl<void*,N>,

                              CloneAllocator >

    {

    private:

        typedef ptr_sequence_adapter< T,

                                      ptr_container_detail::ptr_array_impl<void*,N>,

                                      CloneAllocator >

            base_class;

        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type U;

        typedef ptr_array<T,N,CloneAllocator>

                          this_type;

        ptr_array( const this_type& );

        void operator=( const this_type& );

    public:

        typedef std::size_t size_type;

        typedef U*          value_type;

        typedef U*          pointer;

        typedef U&          reference;

        typedef const U&    const_reference;

        typedef BOOST_DEDUCED_TYPENAME base_class::auto_type

                            auto_type;

    public: // constructors

        ptr_array() : base_class()

        { }

        ptr_array( std::auto_ptr<this_type> r )

        : base_class( r ) { }

        void operator=( std::auto_ptr<this_type> r )

        {

            base_class::operator=(r);

        }

        std::auto_ptr<this_type> release()

        {

            std::auto_ptr<this_type> ptr( new this_type );

            this->swap( *ptr );

            return ptr;

        }

        std::auto_ptr<this_type> clone() const

        {

            std::auto_ptr<this_type> pa( new this_type );

            for( size_t i = 0; i != N; ++i )

            {

                if( ! is_null(i) )

                    pa->replace( i, CloneAllocator::allocate_clone( (*this)[i] ) );

            }

            return pa;

        }

    private: // hide some members

        using base_class::insert;

        using base_class::erase;

        using base_class::push_back;

        using base_class::push_front;

        using base_class::pop_front;

        using base_class::pop_back;

        using base_class::transfer;

        using base_class::get_allocator;

    public: // compile-time interface

        template< size_t idx >

        auto_type replace( U* r ) // strong

        {

            BOOST_STATIC_ASSERT( idx < N );

            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );

            auto_type res( static_cast<U*>( this->c_private()[idx] ) ); // nothrow

            this->c_private()[idx] = r;                                 // nothrow

            return move(res);                                           // nothrow

        }

        template< size_t idx, class V >

        auto_type replace( std::auto_ptr<V> r )

        {

            return replace<idx>( r.release() );

        }

        auto_type replace( size_t idx, U* r ) // strong

        {

            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );

            auto_type ptr( r );

            BOOST_PTR_CONTAINER_THROW_EXCEPTION( idx >= N, bad_index,

                                                 "'replace()' aout of bounds" );

            auto_type res( static_cast<U*>( this->c_private()[idx] ) ); // nothrow

            this->c_private()[idx] = ptr.release();                     // nothrow

            return move(res);                                           // nothrow

        }

        template< class V >

        auto_type replace( size_t idx, std::auto_ptr<V> r )

        {

            return replace( idx, r.release() );

        }

        using base_class::at;

        template< size_t idx >

        T& at()

        {

            BOOST_STATIC_ASSERT( idx < N );

            return (*this)[idx];

        }

        template< size_t idx >

        const T& at() const

        {

            BOOST_STATIC_ASSERT( idx < N );

            return (*this)[idx];

        }

        bool is_null( size_t idx ) const

        {

            return base_class::is_null(idx);

        }

        template< size_t idx >

        bool is_null() const

        {

            BOOST_STATIC_ASSERT( idx < N );

            return this->c_private()[idx] == 0;

        }

    public: // serialization

        template< class Archive >

        void save( Archive& ar, const unsigned ) const

        {

            this->save_helper( ar );

        }

        template< class Archive >

        void load( Archive& ar, const unsigned ) // basic

        {

            for( size_type i = 0u; i != N; ++i )

            {

                //

                // Remark: pointers are not tracked,

                // so we need not call ar.reset_object_address(v, u)

                //

                T* p;

                ar & p;

                this->replace( i, p );

            }

        }

        BOOST_SERIALIZATION_SPLIT_MEMBER()

    };

    //////////////////////////////////////////////////////////////////////////////

    // clonability

    template< typename T, size_t size, typename CA >

    inline ptr_array<T,size,CA>* new_clone( const ptr_array<T,size,CA>& r )

    {

        return r.clone().release();

    }

    /////////////////////////////////////////////////////////////////////////

    // swap

    template< typename T, size_t size, typename CA >

    inline void swap( ptr_array<T,size,CA>& l, ptr_array<T,size,CA>& r )

    {

        l.swap(r);

    }

}

#endif