//
// 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/
//

#include "test_data.hpp"
#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/bind.hpp>

#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif

template< typename C, typename B, typename T >
void reversible_container_test();

template< class IntContainer >
void algorithms_test();

template< typename C, typename B, typename T >
void reversible_container_test()
{
    using namespace boost;
    
    BOOST_TEST_MESSAGE( "starting reversible container test" ); 
    enum { max_cnt = 10 };
    C  c;
    set_capacity<C>()( c );
    BOOST_CHECK( c.size() == 0 );
    c.push_back( new T );
    BOOST_CHECK( c.size() == 1 );

    const C c2_dummy( c.begin(), c.end() );
    BOOST_CHECK_EQUAL( c2_dummy.size(), c.size() );
    const C c2( c.clone() );
    BOOST_CHECK_EQUAL( c2.size(), c.size() );
    
    C  c3( c.begin(), c.end() );
    set_capacity<C>()( c3 );
    BOOST_CHECK_EQUAL( c.size(), c3.size() );

    c.assign( c3.begin(), c3.end() );
    BOOST_CHECK_EQUAL( c.size(), c3.size() );
        
    c.assign( c3 );
    set_capacity<C>()( c );
    BOOST_TEST_MESSAGE( "finished construction test" ); 

    C a_copy( c );
    BOOST_CHECK_EQUAL( a_copy.size(), c.size() );
    a_copy = a_copy;
    BOOST_CHECK_EQUAL( a_copy.size(), c.size() );
    a_copy.clear();
    a_copy = a_copy;
    BOOST_CHECK( a_copy.empty() );
    BOOST_CHECK( !c.empty() );
    BOOST_TEST_MESSAGE( "finished copying test" ); 

    BOOST_DEDUCED_TYPENAME C::allocator_type alloc        = c.get_allocator();
    hide_warning(alloc);
    BOOST_DEDUCED_TYPENAME C::iterator i                  = c.begin();
    BOOST_DEDUCED_TYPENAME C::const_iterator ci           = c2.begin();
    BOOST_DEDUCED_TYPENAME C::iterator i2                 = c.end();
    hide_warning(i2);
    BOOST_DEDUCED_TYPENAME C::const_iterator ci2          = c2.begin();
    hide_warning(ci2);
    BOOST_DEDUCED_TYPENAME C::reverse_iterator ri         = c.rbegin();
    hide_warning(ri);
    BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cri  = c2.rbegin();
    hide_warning(cri);
    BOOST_DEDUCED_TYPENAME C::reverse_iterator rv2        = c.rend();
    hide_warning(rv2);
    BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cvr2 = c2.rend();
    hide_warning(cvr2);
    i  = c.rbegin().base();
    ci = c2.rbegin().base();
    i  = c.rend().base();
    ci = c2.rend().base();
    BOOST_CHECK_EQUAL( std::distance( c.rbegin(), c.rend() ),
                       std::distance( c.begin(), c.end() ) );
                         
    BOOST_TEST_MESSAGE( "finished iterator test" ); 

    BOOST_DEDUCED_TYPENAME C::size_type s                 = c.size();
    hide_warning(s);
    BOOST_DEDUCED_TYPENAME C::size_type s2                = c.max_size();
    hide_warning(s2);
    c.push_back( new T );
    std::size_t size = 2u;
#ifndef BOOST_NO_AUTO_PTR
    c.push_back( std::auto_ptr<T>( new T ) );
    ++size;
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
    c.push_back( std::unique_ptr<T>( new T ) );
    ++size;
#endif
    bool b                                                = c.empty();
    BOOST_CHECK( !c.empty() );
    b                                                     = is_null( c.begin() );
    BOOST_CHECK( b == false );
    BOOST_DEDUCED_TYPENAME C::reference r                 = c.front();
    hide_warning(r);
    BOOST_DEDUCED_TYPENAME C::const_reference cr          = c2.front();
    hide_warning(cr);
    BOOST_DEDUCED_TYPENAME C::reference r2                = c.back();
    hide_warning(r2);
    BOOST_DEDUCED_TYPENAME C::const_reference cr2         = c2.back();
    hide_warning(cr2);
    BOOST_TEST_MESSAGE( "finished accessors test" ); 
    
    c.push_back( new T );
    ++size;
    BOOST_CHECK_EQUAL( c.size(), size );

    c.pop_back(); 
    BOOST_CHECK( !c.empty() );
    c.insert( c.end(), new T );
#ifndef BOOST_NO_AUTO_PTR
    std::auto_ptr<T> ap(new T);
    c.insert( c.end(), ap );
    ++size;
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
    std::unique_ptr<T> up( new T );
    c.insert( c.end(), std::move( up ) );
    ++size;
#endif
    BOOST_CHECK_EQUAL( c.size(), size );

#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#else
    c.insert( c.end(), c3 );
#endif    
    c3.insert( c3.end(), c.begin(), c.end() ); 
    c.erase( c.begin() );
    c3.erase( c3.begin(), c3.end() );
    c3.erase( boost::make_iterator_range(c3) );
    BOOST_CHECK( c3.empty() );
    BOOST_CHECK( !c.empty() );
    c.swap( c3 );
    BOOST_CHECK( !c3.empty() );
    c3.clear();
    BOOST_CHECK( c3.empty() );
    C c4;
    c4.swap(c3);
#ifdef BOOST_NO_SFINAE
#else
    swap(c4,c3);
#endif    
    BOOST_TEST_MESSAGE( "finished modifiers test" ); 
             
    c.push_back( new T ); c.push_back( new T ); c.push_back( new T ); 
    typedef BOOST_DEDUCED_TYPENAME C::auto_type auto_type;

#ifdef BOOST_NO_SFINAE
#else
    auto_type ptr       = c.release( c.begin() );
#endif    
#ifndef BOOST_NO_AUTO_PTR
    std::auto_ptr<C> ap2   = c.release();
#else
    std::unique_ptr<C> up2 = c.release();
#endif
    c                   = c2.clone();
    BOOST_CHECK( !c.empty() );
    auto_type ptr2      = c.replace( c.begin(), new T );
#ifndef BOOST_NO_AUTO_PTR
    ptr2                = c.replace( c.begin(), std::auto_ptr<T>( new T ) );
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
    ptr2                = c.replace( c.begin(), std::unique_ptr<T>( new T ) );
#endif
    BOOST_TEST_MESSAGE( "finished release/clone/replace test" ); 
                     
    c3.push_back( new T );
    c3.push_back( new T );
    c3.push_back( new T );
    c. BOOST_NESTED_TEMPLATE transfer<C>( c.begin(), c3.begin(), c3 );
    c. BOOST_NESTED_TEMPLATE transfer<C>( c.end(), c3.begin(), c3.end(), c3 );
#ifdef BOOST_NO_SFINAE
#else    
    c. BOOST_NESTED_TEMPLATE transfer<C>( c.end(), boost::make_iterator_range( c3 ), c3 );    
    BOOST_CHECK( c3.empty() );
    BOOST_CHECK( !c.empty() );
#endif    
    c3. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), c );
    BOOST_CHECK( !c3.empty() );
    BOOST_CHECK( c.empty() );
    BOOST_TEST_MESSAGE( "finished transfer test" );  

    c3.resize( 0u );
    BOOST_CHECK( c3.empty() );
    c3.resize( 10u );
    BOOST_CHECK_EQUAL( c3.size(), 10u );
    c3.resize( 12u, &*c3.begin() );
    BOOST_CHECK_EQUAL( c3.size(), 12u );
    BOOST_TEST_MESSAGE( "finished resize test" );  
    
}



template< class CDerived, class CBase, class T >
void test_transfer()
{
    BOOST_TEST_MESSAGE( "starting transfer test" );
    CDerived from;
    CBase    to;

    set_capacity<CDerived>()( from );
    set_capacity<CBase>()( to );

    from.push_back( new T );
    from.push_back( new T );
    to. BOOST_NESTED_TEMPLATE transfer<CDerived>( to.end(), from );
    BOOST_TEST_MESSAGE( "finished transfer test" );
}



#include <boost/assign/list_inserter.hpp>
#include <iostream>

template< class Compare, class C >
bool is_sorted( const C& c )
{
    if( c.size() < 2 )
        return true;
    
    typename C::const_iterator prev = c.begin(),
                               e = c.end(),
                               next = prev;
    Compare pred;
    for( ; next != e ; )
    {
        prev = next;
        ++next;

        if( next == c.end() )
            return true;
        
        if( !pred(*prev,*next) )
            return false;
    }
    return true;
}




struct equal_to_int
{
    int i_;
    
    equal_to_int( int i ) : i_(i)
    { }
    
    bool operator()( int i ) const
    {
        return i_ == i; 
    }
};


template< class IntContainer >
void random_access_algorithms_test()
{
    BOOST_TEST_MESSAGE( "starting random accessors algorithms test" );

    IntContainer c;
    set_capacity<IntContainer>()( c );
    assign::push_back( c )
                    ( new int(1) )
                    ( new int(3) )
                    ( new int(6) )
                    ( new int(7) )
                    ( new int(2) )
                    ( new int(2) )
                    ( new int(0) )
                    ( new int(6) )
                    ( new int(3) );
    c.sort();
    BOOST_CHECK( is_sorted< std::less_equal<int> >( c ) );
    BOOST_CHECK_EQUAL( c.size(), 9u );
   
    c.unique();
    BOOST_CHECK_EQUAL( c.size(), 6u );
#ifdef PTR_LIST_TEST
    BOOST_CHECK( c.front() == 0 );
    BOOST_CHECK( c.back() == 7 );
#else
    BOOST_CHECK( c[0] == 0 );
    BOOST_CHECK( c[1] == 1 );
    BOOST_CHECK( c[2] == 2 );
    BOOST_CHECK( c[3] == 3 );
    BOOST_CHECK( c[4] == 6 );
    BOOST_CHECK( c[5] == 7 );
#endif    
    
    c.erase_if( equal_to_int(1) );
    BOOST_CHECK_EQUAL( c.size(), 5u );
#ifdef PTR_LIST_TEST
    BOOST_CHECK_EQUAL( c.front(), 0 );
#else
    BOOST_CHECK_EQUAL( c[0], 0 );
    BOOST_CHECK_EQUAL( c[1], 2 );
#endif    

    c.erase_if( equal_to_int(7) );
    BOOST_CHECK_EQUAL( c.size(), 4u );
    BOOST_CHECK_EQUAL( c.back(), 6 );

    // C = [0,2,3,6]

    IntContainer c2;
    set_capacity<IntContainer>()( c2 );
    assign::push_back( c2 )
                   ( new int(-1) )
                   ( new int(1) )
                   ( new int(4) )
                   ( new int(5) )
                   ( new int(7) );
    BOOST_CHECK( c2.size() == 5u );
    c.merge( c2 );
    BOOST_CHECK( c2.empty() );
    BOOST_CHECK( c.size() == 9u );
    BOOST_CHECK( is_sorted< std::less_equal<int> >( c ) ); 
    BOOST_TEST_MESSAGE( "finished random accessors algorithms test" );
}

#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
#pragma GCC diagnostic pop
#endif