Class template recursive_wrapper

boost::recursive_wrapper — Solves circular dependencies, enabling recursive types.

Synopsis

template<typename T> 
class recursive_wrapper {
public:
  // types
  typedef T type;

  // construct/copy/destruct
  recursive_wrapper();
  recursive_wrapper(const recursive_wrapper &);
  recursive_wrapper(const T &);
  ~recursive_wrapper();

  // modifiers
  void swap(recursive_wrapper &);
  recursive_wrapper & operator=(const recursive_wrapper &);
  recursive_wrapper & operator=(const T &);

  // queries
  T & get();
  const T & get() const;
  T * get_pointer();
  const T * get_pointer() const;
};

Description

The recursive_wrapper class template has an interface similar to a simple value container, but its content is allocated dynamically. This allows recursive_wrapper to hold types T whose member data leads to a circular dependency (e.g., a data member of T has a data member of type T).

The application of recursive_wrapper is easiest understood in context. See “Recursive types with recursive_wrapper” for a demonstration of a common use of the class template.

Notes:

Any type specified as the template argument to recursive_wrapper must be capable of construction via operator new. Thus, for instance, references are not supported.

recursive_wrapper construct/copy/destruct

recursive_wrapper();

Initializes *this by default construction of T.

Requires:	T must fulfill the requirements of the DefaultConstructible [20.1.4] concept.
Throws:	May fail with any exceptions arising from the default constructor of T or, in the event of insufficient memory, with std::bad_alloc.

```
recursive_wrapper(const recursive_wrapper & other);
```
Copies the content of other into *this.

Throws:
May fail with any exceptions arising from the copy constructor of T or, in the event of insufficient memory, with std::bad_alloc.
```
recursive_wrapper(const T & operand);
```
Copies operand into *this.

Throws:
May fail with any exceptions arising from the copy constructor of T or, in the event of insufficient memory, with std::bad_alloc.
```
~recursive_wrapper();
```
Deletes the content of *this.

Throws: Will not throw.

recursive_wrapper modifiers

```
void swap(recursive_wrapper & other);
```
Exchanges contents of *this and other.

Throws:
Will not throw.
```
recursive_wrapper & operator=(const recursive_wrapper & rhs);
```
Assigns the content of rhs to the content of *this.

Requires:
T must fulfill the requirements of the Assignable concept.

Throws:
May fail with any exceptions arising from the assignment operator of T.
```
recursive_wrapper & operator=(const T & rhs);
```
Assigns rhs into the content of *this.

Requires: T must fulfill the requirements of the Assignable concept.

Throws: May fail with any exceptions arising from the assignment operator of T.

recursive_wrapper queries

```
T & get();
const T & get() const;
```
Returns a reference to the content of *this.

Throws: Will not throw.
```
T * get_pointer();
const T * get_pointer() const;
```
Returns a pointer to the content of *this.

Throws:
Will not throw.

Requires:	T must fulfill the requirements of the Assignable concept.
Throws:	May fail with any exceptions arising from the assignment operator of T.