| Home | Libraries | People | FAQ | More

## Class any

boost::any — A class whose instances can hold instances of any type that satisfies ValueType requirements.

## Synopsis

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

    class any {
    public:

      // public member functions
      any() noexcept;
      template<typename ValueType> any(const ValueType &);
      any(const any &);
      any(any &&) noexcept;
      template<typename ValueType>
        any(ValueType &&,
            typename std::enable_if<!std::is_same< any &, ValueType >::value >::type * = 0,
            typename std::enable_if<!std::is_const< ValueType >::value >::type * = 0);
      ~any() noexcept;
      any & swap(any &) noexcept;
      any & operator=(const any &);
      any & operator=(any &&) noexcept;
      template<typename ValueType> any & operator=(ValueType &&);
      bool empty() const noexcept;
      void clear() noexcept;
      const boost::typeindex::type_info & type() const noexcept;
    };

## Description

### `any` public member functions

1.     any() noexcept;

   Postconditions: | this->empty() is true.

2.     template<typename ValueType> any(const ValueType & value);

   Makes a copy of `value`, so that the initial content of the new instance is equivalent in both type and value to `value`.

   Throws: | std::bad_alloc or any exceptions arising from the copy constructor of the contained type.

3.     any(const any & other);

   Copy constructor that copies content of `other` into new instance, so that any content is equivalent in both type and value to the content of `other`, or empty if `other` is empty.

   Throws: | May fail with a `std::bad_alloc` exception or any exceptions arising from the copy constructor of the contained type.

4.     any(any && other) noexcept;

   Move constructor that moves content of `other` into new instance and leaves `other` empty.

   Postconditions: | other->empty() is true
   Throws: | Nothing.

5.     template<typename ValueType>
         any(ValueType && value,
             typename std::enable_if<!std::is_same< any &, ValueType >::value >::type * = 0,
             typename std::enable_if<!std::is_const< ValueType >::value >::type * = 0);

   Forwards `value`, so that the initial content of the new instance is equivalent in both type and value to `value` before the forward.

   Throws: | std::bad_alloc or any exceptions arising from the move or copy constructor of the contained type.

6.     ~any() noexcept;

   Releases any and all resources used in management of instance.

   Throws: | Nothing.

7.     any & swap(any & rhs) noexcept;

   Exchange of the contents of `*this` and `rhs`.

   Returns: | `*this`
   Throws: | Nothing.

8.     any & operator=(const any & rhs);

   Copies content of `rhs` into current instance, discarding previous content, so that the new content is equivalent in both type and value to the content of `rhs`, or empty if `rhs.empty()`.

   Throws: | std::bad_alloc or any exceptions arising from the copy constructor of the contained type. Assignment satisfies the strong guarantee of exception safety.

9.     any & operator=(any && rhs) noexcept;

   Moves content of `rhs` into current instance, discarding previous content, so that the new content is equivalent in both type and value to the content of `rhs` before move, or empty if `rhs.empty()`.

   Postconditions: | `rhs->empty()` is true
   Throws: | Nothing.

10.     template<typename ValueType> any & operator=(ValueType && rhs);

    Forwards `rhs`, discarding previous content, so that the new content of is equivalent in both type and value to `rhs` before forward.

    Throws: | std::bad_alloc or any exceptions arising from the move or copy constructor of the contained type. Assignment satisfies the strong guarantee of exception safety.

11.     bool empty() const noexcept;

    Returns: | `true` if instance is empty, otherwise `false`.
    Throws: | Nothing.

12.     void clear() noexcept;

    Postconditions: | this->empty() is true

13.     const boost::typeindex::type_info & type() const noexcept;

    Useful for querying against types known either at compile time or only at runtime.

    Returns: | the `typeid` of the contained value if instance is non-empty, otherwise `typeid(void)`.