//-----------------------------------------------------------------------------

 // boost variant/recursive_wrapper.hpp header file

 // See http://www.boost.org for updates, documentation, and revision history.

 //-----------------------------------------------------------------------------

 //

 // Copyright (c) 2002-2003

 // Eric Friedman, Itay Maman

 //

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

 #ifndef BOOST_VARIANT_RECURSIVE_WRAPPER_HPP

 #define BOOST_VARIANT_RECURSIVE_WRAPPER_HPP

 #include "boost/variant/recursive_wrapper_fwd.hpp"

 #include "boost/checked_delete.hpp"

 namespace boost {

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

 // class template recursive_wrapper

 //

 // See docs and recursive_wrapper_fwd.hpp for more information.

 //

 template <typename T>

 class recursive_wrapper

 {

 public: // typedefs

     typedef T type;

 private: // representation

     T* p_;

 public: // structors

     ~recursive_wrapper();

     recursive_wrapper();

     recursive_wrapper(const recursive_wrapper& operand);

     recursive_wrapper(const T& operand);

 private: // helpers, for modifiers (below)

     void assign(const T& rhs);

 public: // modifiers

     recursive_wrapper& operator=(const recursive_wrapper& rhs)

     {

         assign( rhs.get() );

         return *this;

     }

     recursive_wrapper& operator=(const T& rhs)

     {

         assign( rhs );

         return *this;

     }

     void swap(recursive_wrapper& operand)

     {

         T* temp = operand.p_;

         operand.p_ = p_;

         p_ = temp;

     }

 public: // queries

     T& get() { return *get_pointer(); }

     const T& get() const { return *get_pointer(); }

     T* get_pointer() { return p_; }

     const T* get_pointer() const { return p_; }

 };

 template <typename T>

 recursive_wrapper<T>::~recursive_wrapper()

 {

     boost::checked_delete(p_);

 }

 template <typename T>

 recursive_wrapper<T>::recursive_wrapper()

     : p_(new T)

 {

 }

 template <typename T>

 recursive_wrapper<T>::recursive_wrapper(const recursive_wrapper& operand)

     : p_(new T( operand.get() ))

 {

 }

 template <typename T>

 recursive_wrapper<T>::recursive_wrapper(const T& operand)

     : p_(new T(operand))

 {

 }

 template <typename T>

 void recursive_wrapper<T>::assign(const T& rhs)

 {

     this->get() = rhs;

 }

 // function template swap

 //

 // Swaps two recursive_wrapper<T> objects of the same type T.

 //

 template <typename T>

 inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs)

 {

     lhs.swap(rhs);

 }

 } // namespace boost

 #endif // BOOST_VARIANT_RECURSIVE_WRAPPER_HPP