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