Class template any

boost::type_erasure::any

Synopsis

// In header: <boost/type_erasure/any.hpp>

template<typename Concept, typename T = _self> 
class any {
public:
  // construct/copy/destruct
  any();
  template<typename U> any(U &&);
  template<typename U, typename Map> any(U &&, const static_binding< Map > &);
  any(const any &);
  template<typename Concept2, typename Tag2> 
    any(const any< Concept2, Tag2 > &);
  template<typename Concept2, typename Tag2, typename Map> 
    any(const any< Concept2, Tag2 > &, const static_binding< Map > &);
  template<typename Concept2, typename Tag2> 
    any(const any< Concept2, Tag2 > &, const binding< Concept > &);
  template<class... U> explicit any(U &&...);
  template<class... U> explicit any(const binding< Concept > &, U &&...);
  template<typename U> any & operator=(U &&);
  ~any();
};

Description

The class template any can store any object that models a specific Concept. It dispatches all the functions defined by the Concept to the contained type at runtime.

Template Parameters

```
typename Concept
```
The Concept that the stored type should model.
```
typename T = _self
```
A placeholder specifying which type this is.

`any` public construct/copy/destruct

```
any();
```
Constructs an empty any.

Except as otherwise noted, all operations on an empty any result in a bad_function_call exception. The copy-constructor of an empty any creates another null any. The destructor of an empty any is a no-op. Comparison operators treat all empty anys as equal. typeid_of applied to an empty any returns typeid(void).

An any which does not include relaxed in its Concept can never be null.

See Also:

is_empty

Requires:

relaxed must be in Concept.

Throws:
Nothing.

template<typename U> any(U && data);

Constructs an any to hold a copy of data. The Concept will be instantiated with the placeholder T bound to U.

	Note
	This constructor never matches if the argument is an `any`, `binding`, or `static_binding`.

Parameters:

data

The object to store in the any.

Requires:

U is a model of Concept.

Requires:

U must be CopyConstructible.

Requires:

Concept must not refer to any non-deduced placeholder besides T.

Throws:

std::bad_alloc or whatever that the copy constructor of U throws.

template<typename U, typename Map> 
  any(U && data, const static_binding< Map > & binding);

Constructs an any to hold a copy of data with explicitly specified placeholder bindings.

	Note
	This constructor never matches if the argument is an `any`.

Parameters:

`binding`	Specifies the types that all the placeholders should bind to.
`data`	The object to store in the `any`.

Requires:

U is a model of Concept.

Requires:

U must be CopyConstructible.

Requires:

Map is an MPL map with an entry for every non-deduced placeholder referred to by Concept.

Requires:

T must map to U in Map.

Throws:

std::bad_alloc or whatever that the copy constructor of U throws.

any(const any & other);

Copies an any.

Parameters:

other

The object to make a copy of.

Requires:

Concept must contain constructible<T(const T&)>. (This is included in copy_constructible<T>)

Throws:

std::bad_alloc or whatever that the copy constructor of the contained type throws.

template<typename Concept2, typename Tag2> 
  any(const any< Concept2, Tag2 > & other);

Upcasts from an any with stricter requirements to an any with weaker requirements.

Parameters:

other

The object to make a copy of.

Requires:

Concept must contain constructible<T(const T&)>.

Requires:

Concept must not refer to any non-deduced placeholder besides T.

Requires:

After substituting T for Tag2, the requirements of Concept2 must be a superset of the requirements of Concept.

Throws:

std::bad_alloc or whatever that the copy constructor of the contained type throws.

template<typename Concept2, typename Tag2, typename Map> 
  any(const any< Concept2, Tag2 > & other, 
      const static_binding< Map > & binding);

Constructs an any from another any.

Parameters:

`binding`	Specifies the mapping between the placeholders used by the two concepts.
`other`	The object to make a copy of.

Requires:

Concept must contain constructible<T(const T&)>.

Requires:

Map must be an MPL map with keys for all the non-deduced placeholders used by Concept and values for the corresponding placeholders in Concept2.

Requires:

After substituting placeholders according to Map, the requirements of Concept2 must be a superset of the requirements of Concept.

Throws:

std::bad_alloc or whatever that the copy constructor of the contained type throws.

template<typename Concept2, typename Tag2> 
  any(const any< Concept2, Tag2 > & other, const binding< Concept > & binding);

Constructs an any from another any.

	Warning
	This constructor is potentially dangerous, as it cannot check at compile time whether the arguments match.

Parameters:

`binding`	Specifies the bindings of placeholders to actual types.
`other`	The object to make a copy of.

Requires:

Concept must contain constructible<T(const T&)>.

Requires:

The type stored in other must match the type expected by binding.

Postconditions:

binding_of(*this) == binding

Throws:

std::bad_alloc or whatever that the copy constructor of the contained type throws.

template<class... U> explicit any(U &&... arg);

Calls a constructor of the contained type. The bindings will be deduced from the arguments.

	Note
	This constructor is never chosen if any other constructor can be called instead.

Parameters:

arg

The arguments to be passed to the underlying constructor.

Requires:

Concept must contain an instance of constructible which can be called with these arguments.

Requires:

At least one of the arguments must by an any with the same Concept as this.

Requires:

The bindings of all the arguments that are any's, must be the same.

Throws:

std::bad_alloc or whatever that the constructor of the contained type throws.

template<class... U> 
  explicit any(const binding< Concept > & binding, U &&... arg);

Calls a constructor of the contained type.

Parameters:

`arg`	The arguments to be passed to the underlying constructor.
`binding`	Specifies the bindings of placeholders to actual types.

Requires:

Concept must contain a matching instance of constructible.

Requires:

The contained type of every argument that is an any, must be the same as that specified by binding.

Postconditions:

binding_of(*this) == binding

Throws:

std::bad_alloc or whatever that the constructor of the contained type throws.

template<typename U> any & operator=(U && other);

Assigns to an any.

If an appropriate overload of assignable is not available and relaxed is in Concept, falls back on constructing from other.

	Note
	If `U` is an `any`, then this can decide dynamically whether to use construction based on the type stored in other.

Throws:

Whatever the assignment operator of the contained type throws. When falling back on construction, throws std::bad_alloc or whatever the move (or copy) constructor of the contained type throws. In this case move assignment provides the strong exception guarantee. When calling a (move) assignment operator of the contained type, the exception guarantee is whatever the contained type provides.

```
~any();
```
Requires:

Concept includes destructible<T>.

Boost C++ Libraries