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