//

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

 //

 //

 // This example is intended to get you started.

 // Notice how the smart container

 //

 // 1. takes ownership of objects

 // 2. transfers ownership

 // 3. applies indirection to iterators 

 // 4. clones objects from other smart containers

 // 

 //

 // First we select which container to use.

 //

 #include <boost/ptr_container/ptr_deque.hpp>

 //

 // we need these later in the example

 //

 #include <boost/assert.hpp>

 #include <string>

 #include <exception>

 //

 // Then we define a small polymorphic class

 // hierarchy.

 // 

 class animal : boost::noncopyable

 {

     virtual std::string do_speak() const = 0;

     std::string name_;

 protected:

     //

     // Animals cannot be copied...

     //

     animal( const animal& r ) : name_( r.name_ )           { }

     void operator=( const animal& );

 private:

     //

     // ...but due to advances in genetics, we can clone them!

     //

     virtual animal* do_clone() const = 0;

 public:

     animal( const std::string& name ) : name_(name)        { }

     virtual ~animal() throw()                              { }

     std::string speak() const

     {

         return do_speak();

     }

     std::string name() const

     {

         return name_;

     }

     animal* clone() const

     {

         return do_clone();

     }

 };

 //

 // An animal is still not Clonable. We need this last hook.

 //

 // Notice that we pass the animal by const reference

 // and return by pointer.

 //

 animal* new_clone( const animal& a )

 {

     return a.clone();

 }

 //

 // We do not need to define 'delete_clone()' since

 // since the default is to call the default 'operator delete()'.

 //

 const std::string muuuh = "Muuuh!";

 const std::string oiink = "Oiiink";

 class cow : public animal

 {

     virtual std::string do_speak() const

     {

         return muuuh;

     }

     virtual animal* do_clone() const

     {

         return new cow( *this );

     }

 public:

     cow( const std::string& name ) : animal(name)          { }

 };

 class pig : public animal

 {

     virtual std::string do_speak() const

     {

         return oiink;

     }

     virtual animal* do_clone() const

     {

         return new pig( *this );

     }

 public:

     pig( const std::string& name ) : animal(name)          { }

 };

 //

 // Then we, of course, need a place to put all

 // those animals.

 //

 class farm

 {

     //

     // This is where the smart containers are handy

     //

     typedef boost::ptr_deque<animal> barn_type;

     barn_type                        barn;

     //

     // An error type

     //

     struct farm_trouble : public std::exception           { };

 public:

     // 

     // We would like to make it possible to

     // iterate over the animals in the farm

     //

     typedef barn_type::iterator  animal_iterator;

     //

     // We also need to count the farm's size...

     //

     typedef barn_type::size_type size_type;

     //

     // And we also want to transfer an animal

     // safely around. The easiest way to think

     // about '::auto_type' is to imagine a simplified

     // 'std::auto_ptr<T>' ... this means you can expect

     // 

     //   T* operator->()

     //   T* release()

     //   deleting destructor

     //

     // but not more.

     //

     typedef barn_type::auto_type  animal_transport;

     // 

     // Create an empty farm.

     //

     farm()                                                 { }

     //

     // We need a constructor that can make a new

     // farm by cloning a range of animals.

     //

     farm( animal_iterator begin, animal_iterator end )

      : 

         //

         // Objects are always cloned before insertion

         // unless we explicitly add a pointer or 

         // use 'release()'. Therefore we actually

         // clone all animals in the range

         //

         barn( begin, end )                               { }

     //

     // ... so we need some other function too

     //

     animal_iterator begin()

     {

         return barn.begin();

     }

     animal_iterator end()

     {

         return barn.end();

     }

     //

     // Here it is quite ok to have an 'animal*' argument.

     // The smart container will handle all ownership

     // issues.

     //

     void buy_animal( animal* a )

     {

         barn.push_back( a );

     }

     //

     // The farm can also be in economical trouble and

     // therefore be in the need to sell animals.

     //

     animal_transport sell_animal( animal_iterator to_sell )

     {

         if( to_sell == end() )

             throw farm_trouble();

         //

         // Here we remove the animal from the barn,

         // but the animal is not deleted yet...it's

         // up to the buyer to decide what

         // to do with it.

         //

         return barn.release( to_sell );

     }

     //

     // How big a farm do we have?

     //

     size_type size() const

     {

         return barn.size();

     }

     //

     // If things are bad, we might choose to sell all animals :-(

     //

     std::auto_ptr<barn_type> sell_farm()

     {

         return barn.release();

     }

     //

     // However, if things are good, we might buy somebody

     // else's farm :-)

     //

     void buy_farm( std::auto_ptr<barn_type> other )

     {

         //

         // This line inserts all the animals from 'other'

         // and is guaranteed either to succeed or to have no

         // effect

         //

         barn.transfer( barn.end(), // insert new animals at the end

                          *other );     // we want to transfer all animals,

                                        // so we use the whole container as argument

         //

         // You might think you would have to do

         //

         // other.release();

         //

         // but '*other' is empty and can go out of scope as it wants

         //

         BOOST_ASSERT( other->empty() );

     }

 }; // class 'farm'.

 #include <boost/test/included/test_exec_monitor.hpp>

 int test_main(int,char *[])

 {

     //

     // First we make a farm

     //

     farm animal_farm;

     BOOST_ASSERT( animal_farm.size() == 0u );

     animal_farm.buy_animal( new pig("Betty") );

     animal_farm.buy_animal( new pig("Benny") );

     animal_farm.buy_animal( new pig("Jeltzin") );

     animal_farm.buy_animal( new cow("Hanz") );

     animal_farm.buy_animal( new cow("Mary") );

     animal_farm.buy_animal( new cow("Frederik") );

     BOOST_ASSERT( animal_farm.size() == 6u );

     //

     // Then we make another farm...it will actually contain

     // a clone of the other farm.

     //

     farm new_farm( animal_farm.begin(), animal_farm.end() );

     BOOST_ASSERT( new_farm.size() == 6u );

     //

     // Is it really clones in the new farm?

     //

     BOOST_ASSERT( new_farm.begin()->name() == "Betty" );

     //

     // Then we search for an animal, Mary (the Crown Princess of Denmark),

     // because we would like to buy her ...

     //

     typedef farm::animal_iterator iterator;

     iterator to_sell;

     for( iterator i   = animal_farm.begin(),

                   end = animal_farm.end();

          i != end; ++i )

     {

         if( i->name() == "Mary" )

         {

             to_sell = i;

             break;

         }

     }

     farm::animal_transport mary = animal_farm.sell_animal( to_sell );

     if( mary->speak() == muuuh )

         //

         // Great, Mary is a cow, and she may live longer

         //

         new_farm.buy_animal( mary.release() );

     else

         //

         // Then the animal would be destroyed (!)

         // when we go out of scope.

         //

         ;

     //

     // Now we can observe some changes to the two farms...

     //

     BOOST_ASSERT( animal_farm.size() == 5u );

     BOOST_ASSERT( new_farm.size()    == 7u );

     //

     // The new farm has however underestimated how much

     // it cost to feed Mary and its owner is forced to sell the farm...

     //

     animal_farm.buy_farm( new_farm.sell_farm() );

     BOOST_ASSERT( new_farm.size()    == 0u );

     BOOST_ASSERT( animal_farm.size() == 12u );     

 	return 0;

 }