Files

131 lines
5.1 KiB
C++

//-----------------------------------------------------------------------------
// boost variant/recursive_wrapper_fwd.hpp header file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
// Copyright (c) 2002 Eric Friedman, Itay Maman
// Copyright (c) 2016-2021 Antony Polukhin
//
// Portions Copyright (C) 2002 David Abrahams
//
// 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)
#ifndef ACTIV_BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
#define ACTIV_BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
#include <ActivBoost/mpl/bool.hpp>
#include <ActivBoost/mpl/aux_/config/ctps.hpp>
#include <ActivBoost/mpl/aux_/lambda_support.hpp>
#include <ActivBoost/type_traits/integral_constant.hpp>
#include <ActivBoost/type_traits/is_constructible.hpp>
#include <ActivBoost/type_traits/is_nothrow_move_constructible.hpp>
namespace Boost {
//////////////////////////////////////////////////////////////////////////
// class template recursive_wrapper
//
// Enables recursive types in templates by breaking cyclic dependencies.
//
// For example:
//
// class my;
//
// typedef variant< int, recursive_wrapper<my> > var;
//
// class my {
// var var_;
// ...
// };
//
template <typename T> class recursive_wrapper;
///////////////////////////////////////////////////////////////////////////////
// metafunction is_constructible partial specializations.
//
// recursive_wrapper<T> is constructible only from T and recursive_wrapper<T>.
//
template <class T> struct is_constructible<recursive_wrapper<T>, T> : Boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const T> : Boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, T&> : Boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const T&> : Boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T> > : Boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T> > : Boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T>& > : Boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T>& > : Boost::true_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, U > : Boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U > : Boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, U& > : Boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U& > : Boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U> > : Boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U> > : Boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U>& > : Boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U>& > : Boost::false_type{};
// recursive_wrapper is not nothrow move constructible, because it's constructor does dynamic memory allocation.
// This specialisation is required to workaround GCC6 issue: https://svn.boost.org/trac/boost/ticket/12680
template <class T> struct is_nothrow_move_constructible<recursive_wrapper<T> > : Boost::false_type{};
///////////////////////////////////////////////////////////////////////////////
// metafunction is_recursive_wrapper (modeled on code by David Abrahams)
//
// True if specified type matches recursive_wrapper<T>.
//
namespace detail {
template <typename T>
struct is_recursive_wrapper_impl
: mpl::false_
{
};
template <typename T>
struct is_recursive_wrapper_impl< recursive_wrapper<T> >
: mpl::true_
{
};
} // namespace detail
template< typename T > struct is_recursive_wrapper
: public ::Boost::integral_constant<bool,(::Boost::detail::is_recursive_wrapper_impl<T>::value)>
{
public:
ACTIV_BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_recursive_wrapper,(T))
};
///////////////////////////////////////////////////////////////////////////////
// metafunction unwrap_recursive
//
// If specified type T matches recursive_wrapper<U>, then U; else T.
//
template <typename T>
struct unwrap_recursive
{
typedef T type;
ACTIV_BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T))
};
template <typename T>
struct unwrap_recursive< recursive_wrapper<T> >
{
typedef T type;
ACTIV_BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,unwrap_recursive,(T))
};
} // namespace Boost
#endif // ACTIV_BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP