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

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