| Home | Libraries | People | FAQ | More

## Class template any

boost::type_erasure::any

## Synopsis

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

    template<typename Concept, typename T = _self>
    class any {
    public:

      // public member functions
      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.

See Also: concept_of, placeholder_of, any_cast, is_empty, binding_of, typeid_of

### Template Parameters

1.     typename Concept

   The Concept that the stored type should model.

2.     typename T = _self

   A placeholder specifying which type this is.

### `any` public member functions

1.     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.

2.     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.

3.     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: |
   `data` | The object to store in the any.
   `binding` | Specifies the types that all the placeholders should bind to.
   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.

4.     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.

5.     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.

6.     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: |
   `other` | The object to make a copy of.
   `binding` | Specifies the mapping between the placeholders used by the two concepts.
   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.

7.     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: |
   `other` | The object to make a copy of.
   `binding` | Specifies the bindings of placeholders to actual types.
   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.

8.     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.

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

   Calls a constructor of the contained type.

   Parameters: |
   `binding` | Specifies the bindings of placeholders to actual types.
   `arg` | The arguments to be passed to the underlying constructor.
   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.

10.     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.

11.     ~any();

    Requires: | `Concept` includes destructible<T>.

### Specializations

- Class template any<Concept, const T &>

- Class template any<Concept, T &>

- Class template any<Concept, T &&>