//
// 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 <boost/test/unit_test.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/ptr_container/ptr_deque.hpp>
#include <boost/ptr_container/ptr_list.hpp>
#include <boost/ptr_container/ptr_array.hpp>
#include <boost/ptr_container/ptr_set.hpp>
#include <boost/ptr_container/ptr_map.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/string.hpp>
#include <fstream>
#include <string>

//
// serialization helper: we can't save a non-const object
// 
template< class T >
inline T const& as_const( T const& r )
{
    return r;
}

//
// class hierarchy
// 
struct Base
{
    friend class boost::serialization::access;

    int i;

    
    template< class Archive >
    void serialize( Archive& ar, const unsigned int version )
    {
        ar & i;
    }

    Base() : i(42)
    { }
    
    Base( int i ) : i(i)
    { }
    
    virtual ~Base()
    { }
};

inline bool operator<( const Base& l, const Base& r )
{
    return l.i < r.i;
}

struct Derived : Base
{
    int i2;

    template< class Archive >
    void serialize( Archive& ar, const unsigned int version )
    {
        ar & boost::serialization::base_object<Base>( *this );
        ar & i2;
    }

    Derived() : Base(42), i2(42)
    { }
    
    explicit Derived( int i2 ) : Base(0), i2(i2)
    { }
};

BOOST_CLASS_EXPORT_GUID( Derived, "Derived" )

//
// test of containers
// 
// 

template< class C, class T >
void add( C& c, T* r, unsigned n )
{
    c.insert( c.end(), r ); 
}

template< class U, class T >
void add( boost::ptr_array<U,2>& c, T* r, unsigned n )
{
    c.replace( n, r );
}

template< class Cont >
void test_serialization_helper()
{
    Cont vec;
    add( vec, new Base( -1 ), 0u );
    add( vec, new Derived( 1 ), 1u );

    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);
    oa << as_const(vec);
    ofs.close();

    
    
    std::ifstream ifs("filename", std::ios::binary);
    boost::archive::text_iarchive ia(ifs);
    Cont vec2;
    ia >> vec2;
    ifs.close();

    BOOST_CHECK_EQUAL( vec.size(), vec2.size() );
    BOOST_CHECK_EQUAL( (*vec2.begin()).i, -1 );
    BOOST_CHECK_EQUAL( (*--vec2.end()).i, 0 );
    typename Cont::iterator i = vec2.end();
    --i;
    Derived* d = dynamic_cast<Derived*>( &*i ); 
    BOOST_CHECK_EQUAL( d->i2, 1 );
}

template< class Map >
void test_serialization_map_helper()
{
    Map m;
    std::string key1("key1"), key2("key2");
    m.insert( key1, new Base( -1 ) );
    m.insert( key2, new Derived( 1 ) );
    BOOST_CHECK_EQUAL( m.size(), 2u );

    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);
    oa << as_const(m);
    ofs.close();


    
    std::ifstream ifs("filename", std::ios::binary);
    boost::archive::text_iarchive ia(ifs);
    Map m2;
    ia >> m2;
    ifs.close();

    BOOST_CHECK_EQUAL( m.size(), m2.size() );
    BOOST_CHECK_EQUAL( m2.find(key1)->second->i, -1 );
    BOOST_CHECK_EQUAL( m2.find(key2)->second->i, 0 );
    typename Map::iterator i = m2.find(key2);
    Derived* d = dynamic_cast<Derived*>( i->second ); 
    BOOST_CHECK_EQUAL( d->i2, 1 );
    
}

//
// basic test of hierarchy
// 
void test_hierarchy()
{
    Base* p = new Derived();
    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);
    oa << as_const(p);
    ofs.close();

    
    Base* d = 0; 
    std::ifstream ifs("filename", std::ios::binary);
    boost::archive::text_iarchive ia(ifs);
    ia >> d;
    ifs.close();
    
    BOOST_CHECK_EQUAL( p->i, d->i );
    BOOST_CHECK( p != d );
    BOOST_CHECK( dynamic_cast<Derived*>( d ) );
    delete p;
    delete d;
} 

//
// test initializer
// 
void test_serialization()
{
    test_hierarchy();
    test_serialization_helper< boost::ptr_deque<Base> >();
    test_serialization_helper< boost::ptr_list<Base> >();
    test_serialization_helper< boost::ptr_vector<Base> >();
    test_serialization_helper< boost::ptr_array<Base,2> >();
  
    test_serialization_helper< boost::ptr_set<Base> >();
    test_serialization_helper< boost::ptr_multiset<Base> >();

    test_serialization_map_helper< boost::ptr_map<std::string,Base> >();

//
// GCC hangs when calling find() on a multimap!
//      
//#if !BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0300))

    test_serialization_map_helper< boost::ptr_multimap<std::string,Base> >();
    
//#endif

}


using boost::unit_test::test_suite;

test_suite* init_unit_test_suite( int argc, char* argv[] )
{
    test_suite* test = BOOST_TEST_SUITE( "Pointer Container Test Suite" );

    test->add( BOOST_TEST_CASE( &test_serialization ) );

    return test;
}