hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 3088

Browse Source
This commit is contained in:
pineappleEA
2022-11-05 15:35:56 +01:00
parent 4e4fc25ce3
commit b601909c6d
35519 changed files with 5996896 additions and 860 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm.hpp vendored Executable file
View File

@@ -0,0 +1,17 @@
/*=============================================================================
Copyright (c) 2004 Angus Leeming
Copyright (c) 2006 Daniel Wallin
Copyright (c) 2005 Dan Marsden
Copyright (c) 2007 Joel de Guzman
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 BOOST_PHOENIX_STL_ALGORITHM_HPP
#define BOOST_PHOENIX_STL_ALGORITHM_HPP
#include <boost/phoenix/stl/algorithm/iteration.hpp>
#include <boost/phoenix/stl/algorithm/querying.hpp>
#include <boost/phoenix/stl/algorithm/transformation.hpp>
#endif // BOOST_PHOENIX_STL_ALGORITHM_HPP

30
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/begin.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
// Copyright 2015 John Fletcher.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
#ifndef BOOST_PHOENIX_ALGORITHM_DETAIL_BEGIN_HPP
#define BOOST_PHOENIX_ALGORITHM_DETAIL_BEGIN_HPP
//#include <boost/range/result_iterator.hpp> is deprecated
#include <boost/range/iterator.hpp>
#include <boost/range/begin.hpp>
namespace boost { namespace phoenix {
namespace detail
{
template<class R>
typename range_iterator<R>::type
begin_(R& r)
{
return boost::begin(r);
}
}
}}
#endif

36
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/decay_array.hpp vendored Executable file
View File

@@ -0,0 +1,36 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
#ifndef BOOST_PHOENIX_ALGORITHM_DETAIL_DECAY_ARRAY_HPP
#define BOOST_PHOENIX_ALGORITHM_DETAIL_DECAY_ARRAY_HPP
namespace boost { namespace phoenix {
namespace detail
{
template<typename T>
struct decay_array
{
typedef T type;
};
template<typename T, int N>
struct decay_array<T[N]>
{
typedef T* type;
};
template<typename T, int N>
struct decay_array<T (&)[N]>
{
typedef T* type;
};
}
}}
#endif

30
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/end.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
// Copyright 2015 John Fletcher.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
#ifndef BOOST_PHOENIX_ALGORITHM_DETAIL_END_HPP
#define BOOST_PHOENIX_ALGORITHM_DETAIL_END_HPP
//#include <boost/range/result_iterator.hpp> is deprecated
#include <boost/range/iterator.hpp>
#include <boost/range/end.hpp>
namespace boost { namespace phoenix {
namespace detail
{
template<class R>
typename range_iterator<R>::type
end_(R& r)
{
return boost::end(r);
}
}
}}
#endif

51
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_equal_range.hpp vendored Executable file
View File

@@ -0,0 +1,51 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_equal_range.hpp
//
/////////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef BOOST_PHOENIX_HAS_EQUAL_RANGE_EN_14_12_2004
#define BOOST_PHOENIX_HAS_EQUAL_RANGE_EN_14_12_2004
#include <boost/mpl/or.hpp>
#include "./is_std_map.hpp"
#include "./is_std_set.hpp"
#include "./is_std_hash_map.hpp"
#include "./is_std_hash_set.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_equal_range
: boost::mpl::or_<
boost::mpl::or_<
is_std_map<T>
, is_std_multimap<T>
, is_std_set<T>
, is_std_multiset<T>
>
, boost::mpl::or_<
is_std_hash_map<T>
, is_std_hash_multimap<T>
, is_std_hash_set<T>
, is_std_hash_multiset<T>
>
>
{
};
}
#endif

56
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_find.hpp vendored Executable file
View File

@@ -0,0 +1,56 @@
///////////////////////////////////////////////////////////////////////////////
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
// Copyright 2015 John Fletcher
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_find.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_HAS_FIND_EN_14_12_2004
#define BOOST_PHOENIX_HAS_FIND_EN_14_12_2004
#include <boost/mpl/or.hpp>
#include "./is_std_map.hpp"
#include "./is_std_set.hpp"
#include "./is_std_hash_map.hpp"
#include "./is_std_hash_set.hpp"
#include "./is_unordered_set_or_map.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_find
: boost::mpl::or_<
boost::mpl::or_<
is_std_map<T>
, is_std_multimap<T>
, is_std_set<T>
, is_std_multiset<T>
>
, boost::mpl::or_<
is_std_hash_map<T>
, is_std_hash_multimap<T>
, is_std_hash_set<T>
, is_std_hash_multiset<T>
>
, boost::mpl::or_<
is_std_unordered_map<T>
, is_std_unordered_multimap<T>
, is_std_unordered_set<T>
, is_std_unordered_multiset<T>
>
>
{
};
}
#endif

51
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_lower_bound.hpp vendored Executable file
View File

@@ -0,0 +1,51 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_lower_bound.hpp
//
/////////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef BOOST_PHOENIX_HAS_LOWER_BOUND_EN_14_12_2004
#define BOOST_PHOENIX_HAS_LOWER_BOUND_EN_14_12_2004
#include <boost/mpl/or.hpp>
#include "./is_std_map.hpp"
#include "./is_std_set.hpp"
#include "./is_std_hash_map.hpp"
#include "./is_std_hash_set.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_lower_bound
: boost::mpl::or_<
boost::mpl::or_<
is_std_map<T>
, is_std_multimap<T>
, is_std_set<T>
, is_std_multiset<T>
>
, boost::mpl::or_<
is_std_hash_map<T>
, is_std_hash_multimap<T>
, is_std_hash_set<T>
, is_std_hash_multiset<T>
>
>
{
};
}
#endif

30
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_remove.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_remove.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_HAS_REMOVE_EN_14_12_2004
#define BOOST_PHOENIX_HAS_REMOVE_EN_14_12_2004
#include "./is_std_list.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_remove
: is_std_list<T>
{
};
}
#endif

34
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_remove_if.hpp vendored Executable file
View File

@@ -0,0 +1,34 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_remove_if.hpp
//
/////////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef BOOST_PHOENIX_HAS_REMOVE_IF_EN_14_12_2004
#define BOOST_PHOENIX_HAS_REMOVE_IF_EN_14_12_2004
#include "./is_std_list.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_remove_if
: is_std_list<T>
{
};
}
#endif

34
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_reverse.hpp vendored Executable file
View File

@@ -0,0 +1,34 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_reverse.hpp
//
/////////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef BOOST_PHOENIX_HAS_REVERSE_EN_14_12_2004
#define BOOST_PHOENIX_HAS_REVERSE_EN_14_12_2004
#include "./is_std_list.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_reverse
: is_std_list<T>
{
};
}
#endif

30
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_sort.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_sort.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_HAS_SORT_EN_14_12_2004
#define BOOST_PHOENIX_HAS_SORT_EN_14_12_2004
#include "./is_std_list.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_sort
: is_std_list<T>
{
};
}
#endif

34
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_unique.hpp vendored Executable file
View File

@@ -0,0 +1,34 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_unique.hpp
//
/////////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef BOOST_PHOENIX_HAS_UNIQUE_EN_14_12_2004
#define BOOST_PHOENIX_HAS_UNIQUE_EN_14_12_2004
#include "./is_std_list.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_unique
: is_std_list<T>
{
};
}
#endif

47
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/has_upper_bound.hpp vendored Executable file
View File

@@ -0,0 +1,47 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// has_upper_bound.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_HAS_UPPER_BOUND_EN_14_12_2004
#define BOOST_PHOENIX_HAS_UPPER_BOUND_EN_14_12_2004
#include <boost/mpl/or.hpp>
#include "./is_std_map.hpp"
#include "./is_std_set.hpp"
#include "./is_std_hash_map.hpp"
#include "./is_std_hash_set.hpp"
namespace boost
{
// Specialize this for user-defined types
template<typename T>
struct has_upper_bound
: boost::mpl::or_<
boost::mpl::or_<
is_std_map<T>
, is_std_multimap<T>
, is_std_set<T>
, is_std_multiset<T>
>
, boost::mpl::or_<
is_std_hash_map<T>
, is_std_hash_multimap<T>
, is_std_hash_set<T>
, is_std_hash_multiset<T>
>
>
{
};
}
#endif

53
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/is_std_hash_map.hpp vendored Executable file
View File

@@ -0,0 +1,53 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// is_std_hash_map.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_IS_STD_HASH_MAP_EN_16_12_2004
#define BOOST_PHOENIX_IS_STD_HASH_MAP_EN_16_12_2004
#include <boost/phoenix/config.hpp>
#include <boost/mpl/bool.hpp>
#ifdef BOOST_PHOENIX_HAS_HASH
#include BOOST_PHOENIX_HASH_MAP_HEADER
#endif
namespace boost
{
template<class T>
struct is_std_hash_map
: boost::mpl::false_
{};
template<class T>
struct is_std_hash_multimap
: boost::mpl::false_
{};
#ifdef BOOST_PHOENIX_HAS_HASH
template<class Kty,class Ty,BOOST_PHOENIX_HASH_template_rest_param>
struct is_std_hash_map< ::BOOST_PHOENIX_HASH_NAMESPACE::hash_map<Kty,Ty,BOOST_PHOENIX_HASH_type_rest_param> >
: boost::mpl::true_
{};
template<class Kty,class Ty,BOOST_PHOENIX_HASH_template_rest_param>
struct is_std_hash_multimap< ::BOOST_PHOENIX_HASH_NAMESPACE::hash_multimap<Kty,Ty,BOOST_PHOENIX_HASH_type_rest_param> >
: boost::mpl::true_
{};
#endif
}
#endif

53
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/is_std_hash_set.hpp vendored Executable file
View File

@@ -0,0 +1,53 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// is_std_hash_set.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_IS_STD_HASH_SET_EN_16_12_2004
#define BOOST_PHOENIX_IS_STD_HASH_SET_EN_16_12_2004
#include <boost/phoenix/config.hpp>
#include <boost/mpl/bool.hpp>
#ifdef BOOST_PHOENIX_HAS_HASH
#include BOOST_PHOENIX_HASH_SET_HEADER
#endif
namespace boost
{
template<class T>
struct is_std_hash_set
: boost::mpl::false_
{};
template<class T>
struct is_std_hash_multiset
: boost::mpl::false_
{};
#ifdef BOOST_PHOENIX_HAS_HASH
template<class Kty,BOOST_PHOENIX_HASH_template_rest_param>
struct is_std_hash_set< ::BOOST_PHOENIX_HASH_NAMESPACE::hash_set<Kty,BOOST_PHOENIX_HASH_type_rest_param> >
: boost::mpl::true_
{};
template<class Kty,BOOST_PHOENIX_HASH_template_rest_param>
struct is_std_hash_multiset< ::BOOST_PHOENIX_HASH_NAMESPACE::hash_multiset<Kty,BOOST_PHOENIX_HASH_type_rest_param> >
: boost::mpl::true_
{};
#endif
}
#endif

37
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/is_std_list.hpp vendored Executable file
View File

@@ -0,0 +1,37 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// is_std_list.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_IS_STD_LIST_EN_16_12_2004
#define BOOST_PHOENIX_IS_STD_LIST_EN_16_12_2004
#include <boost/mpl/bool.hpp>
#include <list>
namespace boost
{
template<class T>
struct is_std_list
: boost::mpl::false_
{};
template<
class Ty
, class Alloc
>
struct is_std_list< ::std::list<Ty,Alloc> >
: boost::mpl::true_
{};
}
#endif

54
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/is_std_map.hpp vendored Executable file
View File

@@ -0,0 +1,54 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// is_std_map.hpp
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_PHOENIX_IS_STD_MAP_EN_16_12_2004
#define BOOST_PHOENIX_IS_STD_MAP_EN_16_12_2004
#include <boost/mpl/bool.hpp>
#include <map>
namespace boost
{
template<class T>
struct is_std_map
: boost::mpl::false_
{};
template<
class Kty
, class Ty
, class Pr
, class Alloc
>
struct is_std_map< ::std::map<Kty,Ty,Pr,Alloc> >
: boost::mpl::true_
{};
template<class T>
struct is_std_multimap
: boost::mpl::false_
{};
template<
class Kty
, class Ty
, class Pr
, class Alloc
>
struct is_std_multimap< ::std::multimap<Kty,Ty,Pr,Alloc> >
: boost::mpl::true_
{};
}
#endif

56
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/is_std_set.hpp vendored Executable file
View File

@@ -0,0 +1,56 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// is_std_set.hpp
//
/////////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
# pragma once
#endif
#ifndef BOOST_PHOENIX_IS_STD_SET_EN_16_12_2004
#define BOOST_PHOENIX_IS_STD_SET_EN_16_12_2004
#include <boost/mpl/bool.hpp>
#include <set>
namespace boost
{
template<class T>
struct is_std_set
: boost::mpl::false_
{};
template<
class Kty
, class Pr
, class Alloc
>
struct is_std_set< ::std::set<Kty,Pr,Alloc> >
: boost::mpl::true_
{};
template<class T>
struct is_std_multiset
: boost::mpl::false_
{};
template<
class Kty
, class Pr
, class Alloc
>
struct is_std_multiset< ::std::multiset<Kty,Pr,Alloc> >
: boost::mpl::true_
{};
}
#endif

100
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/detail/is_unordered_set_or_map.hpp vendored Executable file
View File

@@ -0,0 +1,100 @@
///////////////////////////////////////////////////////////////////////////////
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
// Copyright 2015 John Fletcher
//
// Use, modification and distribution is subject to 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)
//
// This is based on is_std_hash_map.hpp which was
// modeled after range_ex, Copyright 2004 Eric Niebler
///////////////////////////////////////////////////////////////////////////////
//
// is_unordered_set_or_map.hpp
//
/////////////////////////////////////////////////////////////////////////////
// Definitions of overloads for the use of find with unordered types.
#ifndef BOOST_PHOENIX_IS_STD_UNORDERED_SET_OR_MAP
#define BOOST_PHOENIX_IS_STD_UNORDERED_SET_OR_MAP
#include <boost/phoenix/config.hpp>
#include <boost/mpl/bool.hpp>
#ifdef BOOST_PHOENIX_HAS_UNORDERED_SET_AND_MAP
#include BOOST_PHOENIX_UNORDERED_SET_HEADER
#include BOOST_PHOENIX_UNORDERED_MAP_HEADER
#endif
namespace boost
{
template<class T>
struct is_std_unordered_set
: boost::mpl::false_
{};
template<class T>
struct is_std_unordered_multiset
: boost::mpl::false_
{};
template<class T>
struct is_std_unordered_map
: boost::mpl::false_
{};
template<class T>
struct is_std_unordered_multimap
: boost::mpl::false_
{};
#ifdef BOOST_PHOENIX_HAS_UNORDERED_SET_AND_MAP
template<
class Kty
, class Hash
, class Cmp
, class Alloc
>
struct is_std_unordered_set< std::unordered_set<Kty,Hash,Cmp,Alloc> >
: boost::mpl::true_
{};
template<
class Kty
, class Hash
, class Cmp
, class Alloc
>
struct is_std_unordered_multiset< std::unordered_multiset<Kty,Hash,Cmp,Alloc> >
: boost::mpl::true_
{};
template<
class Kty
, class Ty
, class Hash
, class Cmp
, class Alloc
>
struct is_std_unordered_map< std::unordered_map<Kty,Ty,Hash,Cmp,Alloc> >
: boost::mpl::true_
{};
template<
class Kty
, class Ty
, class Hash
, class Cmp
, class Alloc
>
struct is_std_unordered_multimap< std::unordered_multimap<Kty,Ty,Hash,Cmp,Alloc> >
: boost::mpl::true_
{};
#endif
} // namespace boost
#endif

97
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/iteration.hpp vendored Executable file
View File

@@ -0,0 +1,97 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
// Copyright 2005 Dan Marsden.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
#ifndef BOOST_PHOENIX_ALGORITHM_ITERATION_HPP
#define BOOST_PHOENIX_ALGORITHM_ITERATION_HPP
#include <algorithm>
#include <numeric>
#include <boost/phoenix/stl/algorithm/detail/begin.hpp>
#include <boost/phoenix/stl/algorithm/detail/end.hpp>
#include <boost/phoenix/function/adapt_callable.hpp>
namespace boost { namespace phoenix {
namespace impl
{
struct for_each
{
template <typename Sig>
struct result;
template<typename This, class R, class F>
struct result<This(R&, F)>
: result<This(R&, F const &)>
{};
template<typename This, class R, class F>
struct result<This(R&, F &)>
{
typedef F type;
};
template<class R, class F>
F const operator()(R& r, F const& fn) const
{
return std::for_each(detail::begin_(r), detail::end_(r), fn);
}
};
struct accumulate
{
template <typename Sig>
struct result;
template<typename This, class R, class I>
struct result<This(R&, I)>
: result<This(R&, I const &)>
{};
template<typename This, class R, class I>
struct result<This(R&, I &)>
{
typedef I type;
};
template<typename This, class R, class I, class C>
struct result<This(R&, I, C)>
: result<This(R&, I const &, C)>
{};
template<typename This, class R, class I, class C>
struct result<This(R&, I &, C)>
{
typedef I type;
};
template<class R, class I>
I
operator()(R& r, I i) const
{
return std::accumulate(detail::begin_(r), detail::end_(r), i);
}
template<class R, class I, class C>
I
operator()(R& r, I i, C c) const
{
return std::accumulate(detail::begin_(r), detail::end_(r), i, c);
}
};
}
BOOST_PHOENIX_ADAPT_CALLABLE(for_each, impl::for_each, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(accumulate, impl::accumulate, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(accumulate, impl::accumulate, 3)
}}
#endif

660
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/querying.hpp vendored Executable file
View File

@@ -0,0 +1,660 @@
// Copyright 2005 Daniel Wallin.
// Copyright 2005 Joel de Guzman.
// Copyright 2005 Dan Marsden.
// Copyright 2008 Hartmut Kaiser.
// Copyright 2015 John Fletcher.
//
// Use, modification and distribution is subject to 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)
//
// Modeled after range_ex, Copyright 2004 Eric Niebler
#ifndef BOOST_PHOENIX_ALGORITHM_QUERYING_HPP
#define BOOST_PHOENIX_ALGORITHM_QUERYING_HPP
#include <algorithm>
#include <boost/phoenix/core/limits.hpp>
#include <boost/phoenix/stl/algorithm/detail/has_find.hpp>
#include <boost/phoenix/stl/algorithm/detail/has_lower_bound.hpp>
#include <boost/phoenix/stl/algorithm/detail/has_upper_bound.hpp>
#include <boost/phoenix/stl/algorithm/detail/has_equal_range.hpp>
#include <boost/phoenix/stl/algorithm/detail/begin.hpp>
#include <boost/phoenix/stl/algorithm/detail/end.hpp>
#include <boost/phoenix/stl/algorithm/detail/decay_array.hpp>
#include <boost/phoenix/function/adapt_callable.hpp>
//#include <boost/range/result_iterator.hpp> is deprecated
#include <boost/range/iterator.hpp>
#include <boost/range/difference_type.hpp>
namespace boost { namespace phoenix {
namespace impl
{
struct find
{
template <typename Sig>
struct result;
template <typename This, class R, class T>
struct result<This(R&, T&)>
: range_iterator<R>
{};
template<class R, class T>
typename range_iterator<R>::type
execute(R& r, T const& x, mpl::true_) const
{
return r.find(x);
}
template<class R, class T>
typename range_iterator<R>::type
execute(R& r, T const& x, mpl::false_) const
{
return std::find(detail::begin_(r), detail::end_(r), x);
}
template<class R, class T>
typename range_iterator<R>::type
operator()(R& r, T const& x) const
{
return execute(r, x, has_find<R>());
}
};
struct find_if
{
template <typename Sig>
struct result;
template <typename This, class R, class P>
struct result<This(R&, P)>
: range_iterator<R>
{};
template<class R, class P>
typename range_iterator<R>::type
operator()(R& r, P p) const
{
return std::find_if(detail::begin_(r), detail::end_(r), p);
}
};
struct find_end
{
template <typename Sig>
struct result;
template<typename This, class R, class R2>
struct result<This(R&, R2&)>
: range_iterator<R>
{};
template<typename This, class R, class R2, class P>
struct result<This(R&, R2&, P)>
: range_iterator<R>
{};
template<class R, class R2>
typename range_iterator<R>::type
operator()(R& r, R2& r2) const
{
return std::find_end(
detail::begin_(r)
, detail::end_(r)
, detail::begin_(r2)
, detail::end_(r2)
);
}
template<class R, class R2, class P>
typename range_iterator<R>::type
operator()(R& r, R2& r2, P p) const
{
return std::find_end(
detail::begin_(r)
, detail::end_(r)
, detail::begin_(r2)
, detail::end_(r2)
, p
);
}
};
struct find_first_of
{
template <typename Sig>
struct result;
template<typename This, class R, class R2>
struct result<This(R&, R2&)>
: range_iterator<R>
{};
template<typename This, class R, class R2, class P>
struct result<This(R&, R2&, P)>
: range_iterator<R>
{};
template<class R, class R2>
typename range_iterator<R>::type
operator()(R& r, R2& r2) const
{
return std::find_first_of(
detail::begin_(r)
, detail::end_(r)
, detail::begin_(r2)
, detail::end_(r2)
);
}
template<class R, class R2, class P>
typename range_iterator<R>::type
operator()(R& r, R2& r2, P p) const
{
return std::find_first_of(
detail::begin_(r)
, detail::end_(r)
, detail::begin_(r2)
, detail::end_(r2)
, p
);
}
};
struct adjacent_find
{
template <typename Sig>
struct result;
template <typename This, class R>
struct result<This(R&)>
: range_iterator<R>
{};
template <typename This, class R, class P>
struct result<This(R&, P)>
: range_iterator<R>
{};
template<class R>
typename range_iterator<R>::type
operator()(R& r) const
{
return std::adjacent_find(detail::begin_(r), detail::end_(r));
}
template<class R, class P>
typename range_iterator<R>::type
operator()(R& r, P p) const
{
return std::adjacent_find(detail::begin_(r), detail::end_(r), p);
}
};
struct count
{
template <typename Sig>
struct result;
template <typename This, class R, class T>
struct result<This(R&, T&)>
: range_difference<R>
{};
template<class R, class T>
typename range_difference<R>::type
operator()(R& r, T const& x) const
{
return std::count(detail::begin_(r), detail::end_(r), x);
}
};
struct count_if
{
template <typename Sig>
struct result;
template <typename This, class R, class P>
struct result<This(R&, P)>
: range_difference<R>
{};
template<class R, class P>
typename range_difference<R>::type
operator()(R& r, P p) const
{
return std::count_if(detail::begin_(r), detail::end_(r), p);
}
};
struct distance
{
template <typename Sig>
struct result;
template <typename This, class R>
struct result<This(R&)>
: range_difference<R>
{};
template<class R>
typename range_difference<R>::type
operator()(R& r) const
{
return std::distance(detail::begin_(r), detail::end_(r));
}
};
struct equal
{
typedef bool result_type;
template<class R, class I>
bool operator()(R& r, I i) const
{
return std::equal(detail::begin_(r), detail::end_(r), i);
}
template<class R, class I, class P>
bool operator()(R& r, I i, P p) const
{
return std::equal(detail::begin_(r), detail::end_(r), i, p);
}
};
struct search
{
template <typename Sig>
struct result;
template <typename This, class R, typename R2>
struct result<This(R&, R2&)>
: range_iterator<R>
{};
template <typename This, class R, typename R2, class P>
struct result<This(R&, R2&, P)>
: range_iterator<R>
{};
template<class R, class R2>
typename range_iterator<R>::type
operator()(R& r, R2& r2) const
{
return std::search(
detail::begin_(r)
, detail::end_(r)
, detail::begin_(r2)
, detail::end_(r2)
);
}
template<class R, class R2, class P>
typename range_iterator<R>::type
operator()(R& r, R2& r2, P p) const
{
return std::search(
detail::begin_(r)
, detail::end_(r)
, detail::begin_(r2)
, detail::end_(r2)
, p
);
}
};
struct lower_bound
{
template <typename Sig>
struct result;
template <typename This, class R, class T>
struct result<This(R&, T&)>
: range_iterator<R>
{};
template <typename This, class R, class T, class C>
struct result<This(R&, T&, C)>
: range_iterator<R>
{};
template<class R, class T>
typename range_iterator<R>::type
execute(R& r, T const& val, mpl::true_) const
{
return r.lower_bound(val);
}
template<class R, class T>
typename range_iterator<R>::type
execute(R& r, T const& val, mpl::false_) const
{
return std::lower_bound(detail::begin_(r), detail::end_(r), val);
}
template<class R, class T>
typename range_iterator<R>::type
operator()(R& r, T const& val) const
{
return execute(r, val, has_lower_bound<R>());
}
template<class R, class T, class C>
typename range_iterator<R>::type
operator()(R& r, T const& val, C c) const
{
return std::lower_bound(detail::begin_(r), detail::end_(r), val, c);
}
};
struct upper_bound
{
template <typename Sig>
struct result;
template <typename This, class R, class T>
struct result<This(R&, T&)>
: range_iterator<R>
{};
template <typename This, class R, class T, class C>
struct result<This(R&, T&, C)>
: range_iterator<R>
{};
template<class R, class T>
typename range_iterator<R>::type
execute(R& r, T const& val, mpl::true_) const
{
return r.upper_bound(val);
}
template<class R, class T>
typename range_iterator<R>::type
execute(R& r, T const& val, mpl::false_) const
{
return std::upper_bound(detail::begin_(r), detail::end_(r), val);
}
template<class R, class T>
typename range_iterator<R>::type
operator()(R& r, T const& val) const
{
return execute(r, val, has_upper_bound<R>());
}
template<class R, class T, class C>
typename range_iterator<R>::type
operator()(R& r, T const& val, C c) const
{
return std::upper_bound(detail::begin_(r), detail::end_(r), val, c);
}
};
namespace result_of
{
template <typename R, typename T, typename C = void>
struct equal_range
{
typedef std::pair<
typename range_iterator<R>::type
, typename range_iterator<R>::type
> type;
};
}
struct equal_range
{
template <typename Sig>
struct result;
template <typename This, class R, class T>
struct result<This(R&, T&)>
: result_of::equal_range<R,T>
{};
template <typename This, class R, class T, class C>
struct result<This(R&, T&, C)>
: result_of::equal_range<R,T, C>
{};
template<class R, class T>
typename result_of::equal_range<R, T>::type
execute(R& r, T const& val, mpl::true_) const
{
return r.equal_range(val);
}
template<class R, class T>
typename result_of::equal_range<R, T>::type
execute(R& r, T const& val, mpl::false_) const
{
return std::equal_range(detail::begin_(r), detail::end_(r), val);
}
template<class R, class T>
typename result_of::equal_range<R, T>::type
operator()(R& r, T const& val) const
{
return execute(r, val, has_equal_range<R>());
}
template<class R, class T, class C>
typename result_of::equal_range<R, T, C>::type
operator()(R& r, T const& val, C c) const
{
return std::equal_range(detail::begin_(r), detail::end_(r), val, c);
}
};
namespace result_of
{
template <typename R, typename I, typename P = void>
struct mismatch
{
typedef std::pair<
typename range_iterator<R>::type
, typename detail::decay_array<I>::type
> type;
};
}
struct mismatch
{
template <typename Sig>
struct result;
template<typename This, class R, class I>
struct result<This(R&, I)>
: result_of::mismatch<R, I>
{};
template<typename This, class R, class I, class P>
struct result<This(R&, I, P)>
: result_of::mismatch<R, I, P>
{};
template<class R, class I>
typename result_of::mismatch<R, I>::type
operator()(R& r, I i) const
{
return std::mismatch(detail::begin_(r), detail::end_(r), i);
}
template<class R, class I, class P>
typename result_of::mismatch<R, I, P>::type
operator()(R& r, I i, P p) const
{
return std::mismatch(detail::begin_(r), detail::end_(r), i, p);
}
};
struct binary_search
{
typedef bool result_type;
template<class R, class T>
bool operator()(R& r, T const& val) const
{
return std::binary_search(detail::begin_(r), detail::end_(r), val);
}
template<class R, class T, class C>
bool operator()(R& r, T const& val, C c) const
{
return std::binary_search(detail::begin_(r), detail::end_(r), val, c);
}
};
struct includes
{
typedef bool result_type;
template<class R1, class R2>
bool operator()(R1& r1, R2& r2) const
{
return std::includes(
detail::begin_(r1), detail::end_(r1)
, detail::begin_(r2), detail::end_(r2)
);
}
template<class R1, class R2, class C>
bool operator()(R1& r1, R2& r2, C c) const
{
return std::includes(
detail::begin_(r1), detail::end_(r1)
, detail::begin_(r2), detail::end_(r2)
, c
);
}
};
struct min_element
{
template <typename Sig>
struct result;
template <typename This, class R>
struct result<This(R&)>
: range_iterator<R>
{};
template <typename This, class R, class P>
struct result<This(R&, P)>
: range_iterator<R>
{};
template<class R>
typename range_iterator<R>::type
operator()(R& r) const
{
return std::min_element(detail::begin_(r), detail::end_(r));
}
template<class R, class P>
typename range_iterator<R>::type
operator()(R& r, P p) const
{
return std::min_element(detail::begin_(r), detail::end_(r), p);
}
};
struct max_element
{
template <typename Sig>
struct result;
template <typename This, class R>
struct result<This(R&)>
: range_iterator<R>
{};
template <typename This, class R, class P>
struct result<This(R&, P)>
: range_iterator<R>
{};
template<class R>
typename range_iterator<R>::type
operator()(R& r) const
{
return std::max_element(detail::begin_(r), detail::end_(r));
}
template<class R, class P>
typename range_iterator<R>::type
operator()(R& r, P p) const
{
return std::max_element(detail::begin_(r), detail::end_(r), p);
}
};
struct lexicographical_compare
{
typedef bool result_type;
template<class R1, class R2>
bool operator()(R1& r1, R2& r2) const
{
return std::lexicographical_compare(
detail::begin_(r1), detail::end_(r1)
, detail::begin_(r2), detail::end_(r2)
);
}
template<class R1, class R2, class P>
bool operator()(R1& r1, R2& r2, P p) const
{
return std::lexicographical_compare(
detail::begin_(r1), detail::end_(r1)
, detail::begin_(r2), detail::end_(r2)
, p
);
}
};
}
BOOST_PHOENIX_ADAPT_CALLABLE(find, impl::find, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(find_if, impl::find_if, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(find_end, impl::find_end, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(find_end, impl::find_end, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(find_first_of, impl::find_first_of, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(find_first_of, impl::find_first_of, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(adjacent_find, impl::adjacent_find, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(adjacent_find, impl::adjacent_find, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(count, impl::count, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(count_if, impl::count_if, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(distance, impl::distance, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(equal, impl::equal, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(equal, impl::equal, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(search, impl::search, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(search, impl::search, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(lower_bound, impl::lower_bound, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(lower_bound, impl::lower_bound, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(upper_bound, impl::upper_bound, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(upper_bound, impl::upper_bound, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(equal_range, impl::equal_range, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(equal_range, impl::equal_range, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(mismatch, impl::mismatch, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(mismatch, impl::mismatch, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(binary_search, impl::binary_search, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(binary_search, impl::binary_search, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(includes, impl::includes, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(includes, impl::includes, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(min_element, impl::min_element, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(min_element, impl::min_element, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(max_element, impl::max_element, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(max_element, impl::max_element, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(lexicographical_compare, impl::lexicographical_compare, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(lexicographical_compare, impl::lexicographical_compare, 3)
}}
#endif

1201
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/algorithm/transformation.hpp vendored Executable file
View File

File diff suppressed because it is too large Load Diff

82
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/cmath.hpp vendored Executable file
View File

@@ -0,0 +1,82 @@
/*==============================================================================
Copyright (c) 2011 Steven Watanabe
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 BOOST_PHOENIX_CMATH_HPP_INCLUDED
#define BOOST_PHOENIX_CMATH_HPP_INCLUDED
#include <boost/phoenix/core/limits.hpp>
#include <cmath>
#include <boost/phoenix/function/adapt_callable.hpp>
#include <boost/type_traits/declval.hpp>
#include <boost/phoenix/support/iterate.hpp>
namespace boost {
#if (defined (BOOST_NO_CXX11_DECLTYPE) || \
defined (BOOST_INTEL_CXX_VERSION) || \
(BOOST_GCC_VERSION < 40500) )
#define BOOST_PHOENIX_MATH_FUNCTION_RESULT_TYPE(name, n) \
typename proto::detail::uncvref<A0>::type
#else
#define BOOST_PHOENIX_MATH_FUNCTION_RESULT_TYPE(name, n) \
decltype(name(BOOST_PP_ENUM_BINARY_PARAMS( \
n \
, boost::declval<typename proto::detail::uncvref<A \
, >::type>() BOOST_PP_INTERCEPT)))
#endif
#define BOOST_PHOENIX_MATH_FUNCTION(name, n) \
namespace phoenix_impl { \
struct name ## _impl { \
template<class Sig> \
struct result; \
template<class This, BOOST_PHOENIX_typename_A(n)> \
struct result<This(BOOST_PHOENIX_A(n))> \
{ \
typedef \
BOOST_PHOENIX_MATH_FUNCTION_RESULT_TYPE(name, n) \
type; \
}; \
template<BOOST_PHOENIX_typename_A(n)> \
typename result<name ## _impl(BOOST_PHOENIX_A(n))>::type \
operator()(BOOST_PHOENIX_A_const_ref_a(n)) const { \
using namespace std; \
return name(BOOST_PHOENIX_a(n)); \
} \
}; \
} \
namespace phoenix { \
BOOST_PHOENIX_ADAPT_CALLABLE(name, phoenix_impl::name ## _impl, n) \
}
BOOST_PHOENIX_MATH_FUNCTION(acos, 1)
BOOST_PHOENIX_MATH_FUNCTION(asin, 1)
BOOST_PHOENIX_MATH_FUNCTION(atan, 1)
BOOST_PHOENIX_MATH_FUNCTION(atan2, 2)
BOOST_PHOENIX_MATH_FUNCTION(ceil, 1)
BOOST_PHOENIX_MATH_FUNCTION(cos, 1)
BOOST_PHOENIX_MATH_FUNCTION(cosh, 1)
BOOST_PHOENIX_MATH_FUNCTION(exp, 1)
BOOST_PHOENIX_MATH_FUNCTION(fabs, 1)
BOOST_PHOENIX_MATH_FUNCTION(floor, 1)
BOOST_PHOENIX_MATH_FUNCTION(fmod, 2)
BOOST_PHOENIX_MATH_FUNCTION(frexp, 2)
BOOST_PHOENIX_MATH_FUNCTION(ldexp, 2)
BOOST_PHOENIX_MATH_FUNCTION(log, 1)
BOOST_PHOENIX_MATH_FUNCTION(log10, 1)
BOOST_PHOENIX_MATH_FUNCTION(modf, 2)
BOOST_PHOENIX_MATH_FUNCTION(pow, 2)
BOOST_PHOENIX_MATH_FUNCTION(sin, 1)
BOOST_PHOENIX_MATH_FUNCTION(sinh, 1)
BOOST_PHOENIX_MATH_FUNCTION(sqrt, 1)
BOOST_PHOENIX_MATH_FUNCTION(tan, 1)
BOOST_PHOENIX_MATH_FUNCTION(tanh, 1)
#undef BOOST_PHOENIX_MATH_FUNCTION
}
#endif

13
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/container.hpp vendored Executable file
View File

@@ -0,0 +1,13 @@
/*=============================================================================
Copyright (c) 2004 Angus Leeming
Copyright (c) 2007 Joel de Guzman
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 BOOST_PHOENIX_STL_CONTAINER_HPP
#define BOOST_PHOENIX_STL_CONTAINER_HPP
#include <boost/phoenix/stl/container/container.hpp>
#endif // BOOST_PHOENIX_STL_CONTAINER_HPP

828
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/container/container.hpp vendored Executable file
View File

@@ -0,0 +1,828 @@
/*=============================================================================
Copyright (c) 2004 Angus Leeming
Copyright (c) 2004 Joel de Guzman
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 BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
#define BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
#include <boost/phoenix/core/limits.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/void.hpp>
#include <boost/phoenix/stl/container/detail/container.hpp>
#include <boost/phoenix/function/adapt_callable.hpp>
#include <boost/type_traits/is_const.hpp>
namespace boost { namespace phoenix
{
///////////////////////////////////////////////////////////////////////////////
//
// STL container member functions
//
// Lazy functions for STL container member functions
//
// These functions provide a mechanism for the lazy evaluation of the
// public member functions of the STL containers. For an overview of
// what is meant by 'lazy evaluation', see the comments in operators.hpp
// and functions.hpp.
//
// Lazy functions are provided for all of the member functions of the
// following containers:
//
// deque - list - map - multimap - vector - set - multiset.
//
// Indeed, should *your* class have member functions with the same names
// and signatures as those listed below, then it will automatically be
// supported. To summarize, lazy functions are provided for member
// functions:
//
// assign - at - back - begin - capacity - clear - empty - end -
// erase - front - get_allocator - insert - key_comp - max_size -
// pop_back - pop_front - push_back - push_front - rbegin - rend -
// reserve - resize . size - splice - value_comp.
//
// The lazy functions' names are the same as the corresponding member
// function. Sample usage:
//
// "Normal" version "Lazy" version
// ---------------- --------------
// my_vector.at(5) phoenix::at(arg1, 5)
// my_list.size() phoenix::size(arg1)
// my_vector1.swap(my_vector2) phoenix::swap(arg1, arg2)
//
// Notice that member functions with names that clash with a
// function in stl algorithms are absent. This will be provided
// in Phoenix's algorithm module.
//
// No support is provided here for lazy versions of operator+=,
// operator[] etc. Such operators are not specific to STL containers and
// lazy versions can therefore be found in operators.hpp.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// Lazy member function implementaions.
//
// The structs below provide the guts of the implementation. Thereafter,
// the corresponding lazy function itself is simply:
//
// function<stl::assign> const assign = stl::assign();
//
// The structs provide a nested "result" class template whose
// "type" typedef enables the lazy function to ascertain the type
// to be returned when it is invoked.
//
// They also provide operator() member functions with signatures
// corresponding to those of the underlying member function of
// the STL container.
//
///////////////////////////////////////////////////////////////////////////////
namespace stl
{
struct assign
{
template <typename Sig>
struct result;
template <
typename This
, typename C
, typename Arg1
>
struct result<This(C&, Arg1&)>
{
typedef typename add_reference<C>::type type;
};
template <
typename This
, typename C
, typename Arg1
, typename Arg2
>
struct result<This(C&, Arg1, Arg2)>
{
typedef typename add_reference<C>::type type;
};
template <
typename This
, typename C
, typename Arg1
, typename Arg2
, typename Arg3
>
struct result<This(C&, Arg1, Arg2, Arg3)>
{
typedef typename add_reference<C>::type type;
};
template <typename C, typename Arg1>
C& operator()(C& c, Arg1 const & arg1) const
{
c.assign(arg1);
return c;
}
template <typename C, typename Arg1, typename Arg2>
C& operator()(C& c, Arg1 arg1, Arg2 arg2) const
{
c.assign(arg1, arg2);
return c;
}
template <typename C, typename Arg1, typename Arg2, typename Arg3>
C& operator()(
C& c
, Arg1 arg1
, Arg2 arg2
, Arg3 const & arg3
) const
{
return c.assign(arg1, arg2, arg3);
}
};
struct at_impl
{
template <typename Sig>
struct result;
template <typename This, typename C, typename Index>
struct result<This(C&, Index)>
{
//typedef typename const_qualified_reference_of<C>::type type;
typedef typename C::value_type & type;
};
template <typename C, typename Index>
typename result<at_impl(C&, Index const&)>::type
operator()(C& c, Index const &i) const
{
return c.at(i);
}
template <typename This, typename C, typename Index>
struct result<This(C const&, Index)>
{
typedef typename C::value_type const & type;
};
template <typename C, typename Index>
typename result<at_impl(C const&, Index const&)>::type
operator()(C const& c, Index const &i) const
{
return c.at(i);
}
};
struct back
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef
typename const_qualified_reference_of<C>::type
type;
};
template <typename C>
typename result<back(C&)>::type
operator()(C& c) const
{
return c.back();
}
};
struct begin
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename const_qualified_iterator_of<C>::type type;
};
template <typename C>
typename result<begin(C&)>::type
operator()(C& c) const
{
return c.begin();
}
};
struct capacity
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename size_type_of<C>::type type;
};
template <typename C>
typename result<capacity(C&)>::type
operator()(C const& c) const
{
return c.capacity();
}
};
struct clear
{
typedef void result_type;
template <typename C>
void operator()(C& c) const
{
return c.clear();
}
};
struct empty
{
typedef bool result_type;
template <typename C>
bool operator()(C const& c) const
{
return c.empty();
}
};
struct end
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename const_qualified_iterator_of<C>::type type;
};
template <typename C>
typename result<end(C&)>::type
operator()(C& c) const
{
return c.end();
}
};
namespace result_of
{
template <typename C, typename Arg1, typename Arg2 = mpl::void_>
struct erase
{
// MSVC and libc++ always returns iterator even in C++03 mode.
typedef
boost::mpl::eval_if<
is_key_type_of<C, Arg1>
, size_type_of<C>
#if defined(BOOST_MSVC) /*&& (BOOST_MSVC <= 1500)*/ \
&& (defined(BOOST_LIBSTDCXX11) && 40500 <= BOOST_LIBSTDCXX_VERSION) \
&& defined(_LIBCPP_VERSION)
, iterator_of<C>
#else
, boost::mpl::identity<void>
#endif
>
assoc_erase_result;
typedef typename
boost::mpl::eval_if_c<
has_key_type<C>::value
, assoc_erase_result
, iterator_of<C>
>::type
type;
};
}
struct erase
{
// This mouthful can differentiate between the generic erase
// functions (Container == std::deque, std::list, std::vector) and
// that specific to Associative Containers.
//
// where C is a std::deque, std::list, std::vector:
//
// 1) iterator C::erase(iterator where);
// 2) iterator C::erase(iterator first, iterator last);
//
// where C is a std::map, std::multimap, std::set, or std::multiset:
//
// 3) size_type M::erase(const Key& keyval);
// 4-a) void M::erase(iterator where);
// 4-b) iterator M::erase(iterator where);
// 5-a) void M::erase(iterator first, iterator last);
// 5-b) iterator M::erase(iterator first, iterator last);
template <typename Sig>
struct result;
template <typename This, typename C, typename Arg1>
struct result<This(C&, Arg1)>
: result_of::erase<C, Arg1>
{};
template <typename This, typename C, typename Arg1, typename Arg2>
struct result<This(C&, Arg1, Arg2)>
: result_of::erase<C, Arg1, Arg2>
{};
template <typename C, typename Arg1>
typename result_of::erase<C, Arg1>::type
operator()(C& c, Arg1 arg1) const
{
typedef typename result_of::erase<C, Arg1>::type result_type;
return static_cast<result_type>(c.erase(arg1));
}
template <typename C, typename Arg1, typename Arg2>
typename result_of::erase<C, Arg1, Arg2>::type
operator()(C& c, Arg1 arg1, Arg2 arg2) const
{
typedef typename result_of::erase<C, Arg1, Arg2>::type result_type;
return static_cast<result_type>(c.erase(arg1, arg2));
}
};
struct front
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename const_qualified_reference_of<C>::type type;
};
template <typename C>
typename result<front(C&)>::type
operator()(C& c) const
{
return c.front();
}
};
struct get_allocator
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename allocator_type_of<C>::type type;
};
template <typename C>
typename result<get_allocator(C const&)>::type
operator()(C& c) const
{
return c.get_allocator();
}
};
namespace result_of
{
template <
typename C
, typename Arg1
, typename Arg2 = mpl::void_
, typename Arg3 = mpl::void_
>
class insert
{
struct pair_iterator_bool
{
typedef typename std::pair<typename C::iterator, bool> type;
};
typedef
boost::mpl::eval_if<
map_insert_returns_pair<typename remove_const<C>::type>
, pair_iterator_bool
, iterator_of<C>
>
choice_1;
typedef
boost::mpl::eval_if_c<
boost::mpl::and_<
boost::is_same<Arg3, mpl::void_>
, boost::mpl::not_<boost::is_same<Arg1, Arg2> >
>::value
, iterator_of<C>
, boost::mpl::identity<void>
>
choice_2;
public:
typedef typename
boost::mpl::eval_if_c<
boost::is_same<Arg2, mpl::void_>::value
, choice_1
, choice_2
>::type
type;
};
}
struct insert
{
// This mouthful can differentiate between the generic insert
// functions (Container == deque, list, vector) and those
// specific to the two map-types, std::map and std::multimap.
//
// where C is a std::deque, std::list, std::vector:
//
// 1) iterator C::insert(iterator where, value_type value);
// 2) void C::insert(
// iterator where, size_type count, value_type value);
// 3) template <typename Iter>
// void C::insert(iterator where, Iter first, Iter last);
//
// where M is a std::map and MM is a std::multimap:
//
// 4) pair<iterator, bool> M::insert(value_type const&);
// 5) iterator MM::insert(value_type const&);
//
// where M is a std::map or std::multimap:
//
// 6) template <typename Iter>
// void M::insert(Iter first, Iter last);
template <typename Sig>
struct result;
template <
typename This
, typename C
, typename Arg1
>
struct result<This(C &, Arg1)>
: result_of::insert<C, Arg1>
{};
template <
typename This
, typename C
, typename Arg1
, typename Arg2
>
struct result<This(C &, Arg1, Arg2)>
: result_of::insert<C, Arg1, Arg2>
{};
template <
typename This
, typename C
, typename Arg1
, typename Arg2
, typename Arg3
>
struct result<This(C &, Arg1, Arg2, Arg3)>
: result_of::insert<C, Arg1, Arg2, Arg3>
{};
template <typename C, typename Arg1>
typename result<insert(C&, Arg1)>::type
operator()(C& c, Arg1 arg1) const
{
return c.insert(arg1);
}
template <typename C, typename Arg1, typename Arg2>
typename result<insert(C&, Arg1, Arg2)>::type
operator()(C& c, Arg1 arg1, Arg2 arg2) const
{
typedef typename result<insert(C&, Arg1, Arg2)>::type result_type;
return static_cast<result_type>(c.insert(arg1, arg2));
}
template <typename C, typename Arg1, typename Arg2, typename Arg3>
typename result<insert(C&, Arg1, Arg2, Arg3)>::type
operator()(C& c, Arg1 arg1, Arg2 arg2, Arg3 arg3) const
{
typedef typename result<insert(C&, Arg1, Arg2, Arg3)>::type result_type;
return static_cast<result_type>(c.insert(arg1, arg2, arg3));
}
};
namespace result_of
{
template <typename C>
struct key_comp
{
typedef typename key_compare_of<C>::type type;
};
}
struct key_comp
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
: result_of::key_comp<C>
{};
template <typename C>
typename result_of::key_comp<C>::type
operator()(C& c) const
{
return c.key_comp();
}
};
struct max_size
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename size_type_of<C>::type type;
};
template <typename C>
typename result<max_size(C const&)>::type
operator()(C& c) const
{
return c.max_size();
}
};
struct pop_back
{
typedef void result_type;
template <typename C>
void operator()(C& c) const
{
return c.pop_back();
}
};
struct pop_front
{
typedef void result_type;
template <typename C>
void operator()(C& c) const
{
return c.pop_front();
}
};
struct push_back
{
typedef void result_type;
template <typename C, typename Arg>
void operator()(C& c, Arg const& data) const
{
return c.push_back(data);
}
};
struct push_front
{
typedef void result_type;
template <typename C, typename Arg>
void operator()(C& c, Arg const& data) const
{
return c.push_front(data);
}
};
struct rbegin
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename
const_qualified_reverse_iterator_of<C>::type
type;
};
template <typename C>
typename result<rbegin(C&)>::type
operator()(C& c) const
{
return c.rbegin();
}
};
struct rend
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename
const_qualified_reverse_iterator_of<C>::type
type;
};
template <typename C>
typename result<rend(C&)>::type
operator()(C& c) const
{
return c.rend();
}
};
struct reserve
{
typedef void result_type;
template <typename C, typename Arg>
void operator()(C& c, Arg const& count) const
{
c.reserve(count);
}
};
struct resize
{
typedef void result_type;
template <typename C, typename Arg1>
void operator()(C& c, Arg1 const& arg1) const
{
c.resize(arg1);
}
template <typename C, typename Arg1, typename Arg2>
void operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
{
c.resize(arg1, arg2);
}
};
struct size
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
{
typedef typename size_type_of<C>::type type;
};
template <typename C>
typename result<size(C&)>::type
operator()(C& c) const
{
return c.size();
}
};
struct splice
{
typedef void result_type;
template <typename C, typename Arg1, typename Arg2>
void operator()(C& c, Arg1 arg1, Arg2 &arg2) const
{
c.splice(arg1, arg2);
}
template <
typename C
, typename Arg1
, typename Arg2
, typename Arg3
>
void operator()(
C& c
, Arg1 arg1
, Arg2 & arg2
, Arg3 arg3
) const
{
c.splice(arg1, arg2, arg3);
}
template <
typename C
, typename Arg1
, typename Arg2
, typename Arg3
, typename Arg4
>
void operator()(
C c
, Arg1 arg1
, Arg2 & arg2
, Arg3 arg3
, Arg4 arg4
) const
{
c.splice(arg1, arg2, arg3, arg4);
}
};
namespace result_of
{
template <typename C>
struct value_comp
{
typedef typename value_compare_of<C>::type type;
};
}
struct value_comp
{
template <typename Sig>
struct result;
template <typename This, typename C>
struct result<This(C&)>
: result_of::value_comp<C>
{};
template <typename C>
typename result_of::value_comp<C>::type
operator()(C& c) const
{
return c.value_comp();
}
};
} // namespace stl
///////////////////////////////////////////////////////////////////////////////
//
// The lazy functions themselves.
//
///////////////////////////////////////////////////////////////////////////////
namespace adl_barrier
{
BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 4)
BOOST_PHOENIX_ADAPT_CALLABLE(at, ::boost::phoenix::stl::at_impl, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(back, stl::back, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(begin, stl::begin, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(capacity, stl::capacity, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(clear, stl::clear, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(empty, stl::empty, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(end, stl::end, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(front, stl::front, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(get_allocator, stl::get_allocator, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 4)
BOOST_PHOENIX_ADAPT_CALLABLE(key_comp, stl::key_comp, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(max_size, stl::max_size, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(pop_back, stl::pop_back, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(pop_front, stl::pop_front, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(push_back, stl::push_back, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(push_front, stl::push_front, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(rbegin, stl::rbegin, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(rend, stl::rend, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(reserve, stl::reserve, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(size, stl::size, 1)
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 2)
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 3)
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 4)
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 5)
BOOST_PHOENIX_ADAPT_CALLABLE(value_comp, stl::value_comp, 1)
}
using namespace phoenix::adl_barrier;
}} // namespace boost::phoenix
#endif // BOOST_PHOENIX_STL_CONTAINERS_HPP

211
externals/vcpkg/packages/boost-phoenix_x64-windows/include/boost/phoenix/stl/container/detail/container.hpp vendored Executable file
View File

@@ -0,0 +1,211 @@
/*=============================================================================
Copyright (c) 2004 Angus Leeming
Copyright (c) 2004 Joel de Guzman
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 BOOST_PHOENIX_CONTAINER_DETAIL_CONTAINER_HPP
#define BOOST_PHOENIX_CONTAINER_DETAIL_CONTAINER_HPP
#include <utility>
#include <boost/mpl/eval_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace phoenix { namespace stl
{
///////////////////////////////////////////////////////////////////////////////
//
// Metafunctions "value_type_of", "key_type_of" etc.
//
// These metafunctions define a typedef "type" that returns the nested
// type if it exists. If not then the typedef returns void.
//
// For example, "value_type_of<std::vector<int> >::type" is "int" whilst
// "value_type_of<double>::type" is "void".
//
// I use a macro to define structs "value_type_of" etc simply to cut
// down on the amount of code. The macro is #undef-ed immediately after
// its final use.
//
/////////////////////////////////////////////////////////////////c//////////////
#define MEMBER_TYPE_OF(MEMBER_TYPE) \
template <typename C> \
struct BOOST_PP_CAT(MEMBER_TYPE, _of) \
{ \
typedef typename C::MEMBER_TYPE type; \
}
MEMBER_TYPE_OF(allocator_type);
MEMBER_TYPE_OF(const_iterator);
MEMBER_TYPE_OF(const_reference);
MEMBER_TYPE_OF(const_reverse_iterator);
MEMBER_TYPE_OF(container_type);
MEMBER_TYPE_OF(data_type);
MEMBER_TYPE_OF(iterator);
MEMBER_TYPE_OF(key_compare);
MEMBER_TYPE_OF(key_type);
MEMBER_TYPE_OF(reference);
MEMBER_TYPE_OF(reverse_iterator);
MEMBER_TYPE_OF(size_type);
MEMBER_TYPE_OF(value_compare);
MEMBER_TYPE_OF(value_type);
#undef MEMBER_TYPE_OF
///////////////////////////////////////////////////////////////////////////////
//
// Const-Qualified types.
//
// Many of the stl member functions have const and non-const
// overloaded versions that return distinct types. For example:
//
// iterator begin();
// const_iterator begin() const;
//
// The three class templates defined below,
// const_qualified_reference_of, const_qualified_iterator_of
// and const_qualified_reverse_iterator_of provide a means to extract
// this return type automatically.
//
///////////////////////////////////////////////////////////////////////////////
template <typename C>
struct const_qualified_reference_of
{
typedef typename
boost::mpl::eval_if_c<
boost::is_const<C>::value
, const_reference_of<C>
, reference_of<C>
>::type
type;
};
template <typename C>
struct const_qualified_iterator_of
{
typedef typename
boost::mpl::eval_if_c<
boost::is_const<C>::value
, const_iterator_of<C>
, iterator_of<C>
>::type
type;
};
template <typename C>
struct const_qualified_reverse_iterator_of
{
typedef typename
boost::mpl::eval_if_c<
boost::is_const<C>::value
, const_reverse_iterator_of<C>
, reverse_iterator_of<C>
>::type
type;
};
///////////////////////////////////////////////////////////////////////////////
//
// has_mapped_type<C>
//
// Given a container C, determine if it is a map, multimap, unordered_map,
// or unordered_multimap by checking if it has a member type named "mapped_type".
//
///////////////////////////////////////////////////////////////////////////////
namespace stl_impl
{
struct one { char a[1]; };
struct two { char a[2]; };
template <typename C>
one has_mapped_type(typename C::mapped_type(*)());
template <typename C>
two has_mapped_type(...);
}
template <typename C>
struct has_mapped_type
: boost::mpl::bool_<
sizeof(stl_impl::has_mapped_type<C>(0)) == sizeof(stl_impl::one)
>
{};
///////////////////////////////////////////////////////////////////////////////
//
// has_key_type<C>
//
// Given a container C, determine if it is a Associative Container
// by checking if it has a member type named "key_type".
//
///////////////////////////////////////////////////////////////////////////////
namespace stl_impl
{
template <typename C>
one has_key_type(typename C::key_type(*)());
template <typename C>
two has_key_type(...);
}
template <typename C>
struct has_key_type
: boost::mpl::bool_<
sizeof(stl_impl::has_key_type<C>(0)) == sizeof(stl_impl::one)
>
{};
///////////////////////////////////////////////////////////////////////////////
//
// is_key_type_of<C, Arg>
//
// Lazy evaluation friendly predicate.
//
///////////////////////////////////////////////////////////////////////////////
template <typename C, typename Arg>
struct is_key_type_of
: boost::is_convertible<Arg, typename key_type_of<C>::type>
{};
///////////////////////////////////////////////////////////////////////////////
//
// map_insert_returns_pair<C>
//
// Distinguish a map from a multimap by checking the return type
// of its "insert" member function. A map returns a pair while
// a multimap returns an iterator.
//
///////////////////////////////////////////////////////////////////////////////
namespace stl_impl
{
// Cool implementation of map_insert_returns_pair by Daniel Wallin.
// Thanks Daniel!!! I owe you a Pizza!
template<class A, class B>
one map_insert_returns_pair_check(std::pair<A,B> const&);
template <typename T>
two map_insert_returns_pair_check(T const&);
template <typename C>
struct map_insert_returns_pair
{
static typename C::value_type const& get;
BOOST_STATIC_CONSTANT(int,
value = sizeof(
map_insert_returns_pair_check(((C*)0)->insert(get))));
typedef boost::mpl::bool_<value == sizeof(one)> type;
};
}
template <typename C>
struct map_insert_returns_pair
: stl_impl::map_insert_returns_pair<C>::type {};
}}} // namespace boost::phoenix::stl
#endif // BOOST_PHOENIX_STL_CONTAINER_TRAITS_HPP