Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for a snapshot of the develop branch, built from commit c5994560ca.
PrevUpHomeNext

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.

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 construct/copy/destruct

  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] 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] 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.
  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:

    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.
  7. template<typename Concept2, typename Tag2> 
      any(const any< Concept2, Tag2 > & other, const binding< Concept > & binding);

    Constructs an any from another any.

    [Warning] 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.
  8. template<class... U> explicit any(U &&... arg);

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

    [Note] 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:

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


PrevUpHomeNext