Edit: /usr/include/boost/any.hpp (9472B)
// See http://www.boost.org/libs/any for Documentation.
#ifndef BOOST_ANY_INCLUDED
#define BOOST_ANY_INCLUDED
#if defined(_MSC_VER)
# pragma once
#endif
// what: variant type boost::any
// who: contributed by Kevlin Henney,
// with features contributed and bugs found by
// Antony Polukhin, Ed Brey, Mark Rodgers,
// Peter Dimov, and James Curran
// when: July 2001, April 2013 - 2020
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost
{
class any
{
public: // structors
BOOST_CONSTEXPR any() BOOST_NOEXCEPT
: content(0)
{
}
template
any(const ValueType & value)
: content(new holder<
BOOST_DEDUCED_TYPENAME remove_cv::type>::type
>(value))
{
}
any(const any & other)
: content(other.content ? other.content->clone() : 0)
{
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
// Move constructor
any(any&& other) BOOST_NOEXCEPT
: content(other.content)
{
other.content = 0;
}
// Perfect forwarding of ValueType
template
any(ValueType&& value
, typename boost::disable_if >::type* = 0 // disable if value has type `any&`
, typename boost::disable_if >::type* = 0) // disable if value has type `const ValueType&&`
: content(new holder< typename decay::type >(static_cast(value)))
{
}
#endif
~any() BOOST_NOEXCEPT
{
delete content;
}
public: // modifiers
any & swap(any & rhs) BOOST_NOEXCEPT
{
placeholder* tmp = content;
content = rhs.content;
rhs.content = tmp;
return *this;
}
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
template
any & operator=(const ValueType & rhs)
{
any(rhs).swap(*this);
return *this;
}
any & operator=(any rhs)
{
rhs.swap(*this);
return *this;
}
#else
any & operator=(const any& rhs)
{
any(rhs).swap(*this);
return *this;
}
// move assignment
any & operator=(any&& rhs) BOOST_NOEXCEPT
{
rhs.swap(*this);
any().swap(rhs);
return *this;
}
// Perfect forwarding of ValueType
template
any & operator=(ValueType&& rhs)
{
any(static_cast(rhs)).swap(*this);
return *this;
}
#endif
public: // queries
bool empty() const BOOST_NOEXCEPT
{
return !content;
}
void clear() BOOST_NOEXCEPT
{
any().swap(*this);
}
const boost::typeindex::type_info& type() const BOOST_NOEXCEPT
{
return content ? content->type() : boost::typeindex::type_id().type_info();
}
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
private: // types
#else
public: // types (public so any_cast can be non-friend)
#endif
class BOOST_SYMBOL_VISIBLE placeholder
{
public: // structors
virtual ~placeholder()
{
}
public: // queries
virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT = 0;
virtual placeholder * clone() const = 0;
};
template
class holder
#ifndef BOOST_NO_CXX11_FINAL
final
#endif
: public placeholder
{
public: // structors
holder(const ValueType & value)
: held(value)
{
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
holder(ValueType&& value)
: held(static_cast< ValueType&& >(value))
{
}
#endif
public: // queries
const boost::typeindex::type_info& type() const BOOST_NOEXCEPT BOOST_OVERRIDE
{
return boost::typeindex::type_id().type_info();
}
placeholder * clone() const BOOST_OVERRIDE
{
return new holder(held);
}
public: // representation
ValueType held;
private: // intentionally left unimplemented
holder & operator=(const holder &);
};
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
private: // representation
template
friend ValueType * any_cast(any *) BOOST_NOEXCEPT;
template
friend ValueType * unsafe_any_cast(any *) BOOST_NOEXCEPT;
#else
public: // representation (public so any_cast can be non-friend)
#endif
placeholder * content;
};
inline void swap(any & lhs, any & rhs) BOOST_NOEXCEPT
{
lhs.swap(rhs);
}
class BOOST_SYMBOL_VISIBLE bad_any_cast :
#ifndef BOOST_NO_RTTI
public std::bad_cast
#else
public std::exception
#endif
{
public:
const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
{
return "boost::bad_any_cast: "
"failed conversion using boost::any_cast";
}
};
template
ValueType * any_cast(any * operand) BOOST_NOEXCEPT
{
return operand && operand->type() == boost::typeindex::type_id()
? boost::addressof(
static_cast::type> *>(operand->content)->held
)
: 0;
}
template
inline const ValueType * any_cast(const any * operand) BOOST_NOEXCEPT
{
return any_cast(const_cast(operand));
}
template
ValueType any_cast(any & operand)
{
typedef BOOST_DEDUCED_TYPENAME remove_reference::type nonref;
nonref * result = any_cast(boost::addressof(operand));
if(!result)
boost::throw_exception(bad_any_cast());
// Attempt to avoid construction of a temporary object in cases when
// `ValueType` is not a reference. Example:
// `static_cast(*result);`
// which is equal to `std::string(*result);`
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::is_reference::value,
ValueType,
BOOST_DEDUCED_TYPENAME boost::add_reference::type
>::type ref_type;
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable: 4172) // "returning address of local variable or temporary" but *result is not local!
#endif
return static_cast(*result);
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
}
template
inline ValueType any_cast(const any & operand)
{
typedef BOOST_DEDUCED_TYPENAME remove_reference::type nonref;
return any_cast(const_cast(operand));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template
inline ValueType any_cast(any&& operand)
{
BOOST_STATIC_ASSERT_MSG(
boost::is_rvalue_reference::value /*true if ValueType is rvalue or just a value*/
|| boost::is_const< typename boost::remove_reference::type >::value,
"boost::any_cast shall not be used for getting nonconst references to temporary objects"
);
return any_cast(operand);
}
#endif
// Note: The "unsafe" versions of any_cast are not part of the
// public interface and may be removed at any time. They are
// required where we know what type is stored in the any and can't
// use typeid() comparison, e.g., when our types may travel across
// different shared libraries.
template
inline ValueType * unsafe_any_cast(any * operand) BOOST_NOEXCEPT
{
return boost::addressof(
static_cast *>(operand->content)->held
);
}
template
inline const ValueType * unsafe_any_cast(const any * operand) BOOST_NOEXCEPT
{
return unsafe_any_cast(const_cast(operand));
}
}
// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
// Copyright Antony Polukhin, 2013-2020.
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#endif