anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-25 05:55:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Boost.lexical_cast is not needed anymore.

Browse Source 
As of 9348c5c6, we use std::to_string() instead.

This reduces the size of our boost copy by a couple of MB.
This commit is contained in:
Jean-Marc Lasgouttes 2020-12-11 10:11:08 +01:00
parent a06cdfa073
commit d3036ca705
198 changed files with 0 additions and 45820 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
3rdparty/boost/boost/concept/assert.hpp vendored
View File

@ -1,45 +0,0 @@
// Copyright David Abrahams 2006. 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_CONCEPT_ASSERT_DWA2006430_HPP
# define BOOST_CONCEPT_ASSERT_DWA2006430_HPP
# include <boost/config.hpp>
# include <boost/config/workaround.hpp>
// The old protocol used a constraints() member function in concept
// checking classes. If the compiler supports SFINAE, we can detect
// that function and seamlessly support the old concept checking
// classes. In this release, backward compatibility with the old
// concept checking classes is enabled by default, where available.
// The old protocol is deprecated, though, and backward compatibility
// will no longer be the default in the next release.
# if !defined(BOOST_NO_OLD_CONCEPT_SUPPORT) \
&& !defined(BOOST_NO_SFINAE) \
\
&& !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4))
// Note: gcc-2.96 through 3.3.x have some SFINAE, but no ability to
// check for the presence of particularmember functions.
# define BOOST_OLD_CONCEPT_SUPPORT
# endif
# ifdef BOOST_MSVC
# include <boost/concept/detail/msvc.hpp>
# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
# include <boost/concept/detail/borland.hpp>
# else
# include <boost/concept/detail/general.hpp>
# endif
// Usage, in class or function context:
//
// BOOST_CONCEPT_ASSERT((UnaryFunctionConcept<F,bool,int>));
//
# define BOOST_CONCEPT_ASSERT(ModelInParens) \
BOOST_CONCEPT_ASSERT_FN(void(*)ModelInParens)
#endif // BOOST_CONCEPT_ASSERT_DWA2006430_HPP

16
3rdparty/boost/boost/concept/detail/backward_compatibility.hpp vendored
View File

@ -1,16 +0,0 @@
// Copyright David Abrahams 2009. 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_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
# define BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP
namespace boost
{
namespace concepts {}
# if defined(BOOST_HAS_CONCEPTS) && !defined(BOOST_CONCEPT_NO_BACKWARD_KEYWORD)
namespace concept = concepts;
# endif
} // namespace boost::concept
#endif // BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP

30
3rdparty/boost/boost/concept/detail/borland.hpp vendored
View File

@ -1,30 +0,0 @@
// Copyright David Abrahams 2006. 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_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
# define BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP
# include <boost/preprocessor/cat.hpp>
# include <boost/concept/detail/backward_compatibility.hpp>
namespace boost { namespace concepts {
template <class ModelFnPtr>
struct require;
template <class Model>
struct require<void(*)(Model)>
{
enum { instantiate = sizeof((((Model*)0)->~Model()), 3) };
};
# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr ) \
enum \
{ \
BOOST_PP_CAT(boost_concept_check,__LINE__) = \
boost::concepts::require<ModelFnPtr>::instantiate \
}
}} // namespace boost::concept
#endif // BOOST_CONCEPT_DETAIL_BORLAND_DWA2006429_HPP

34
3rdparty/boost/boost/concept/detail/concept_def.hpp vendored
View File

@ -1,34 +0,0 @@
// Copyright David Abrahams 2006. 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_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
# define BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
# include <boost/preprocessor/seq/for_each_i.hpp>
# include <boost/preprocessor/seq/enum.hpp>
# include <boost/preprocessor/comma_if.hpp>
# include <boost/preprocessor/cat.hpp>
#endif // BOOST_CONCEPT_DETAIL_CONCEPT_DEF_DWA200651_HPP
// BOOST_concept(SomeName, (p1)(p2)...(pN))
//
// Expands to "template <class p1, class p2, ...class pN> struct SomeName"
//
// Also defines an equivalent SomeNameConcept for backward compatibility.
// Maybe in the next release we can kill off the "Concept" suffix for good.
# define BOOST_concept(name, params) \
template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
struct name; /* forward declaration */ \
\
template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
struct BOOST_PP_CAT(name,Concept) \
: name< BOOST_PP_SEQ_ENUM(params) > \
{ \
}; \
\
template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
struct name
// Helper for BOOST_concept, above.
# define BOOST_CONCEPT_typename(r, ignored, index, t) \
BOOST_PP_COMMA_IF(index) typename t

5
3rdparty/boost/boost/concept/detail/concept_undef.hpp vendored
View File

@ -1,5 +0,0 @@
// Copyright David Abrahams 2006. 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)
# undef BOOST_concept_typename
# undef BOOST_concept

77
3rdparty/boost/boost/concept/detail/general.hpp vendored
View File

@ -1,77 +0,0 @@
// Copyright David Abrahams 2006. 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_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
# define BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP
# include <boost/config.hpp>
# include <boost/preprocessor/cat.hpp>
# include <boost/concept/detail/backward_compatibility.hpp>
# ifdef BOOST_OLD_CONCEPT_SUPPORT
# include <boost/concept/detail/has_constraints.hpp>
# include <boost/type_traits/conditional.hpp>
# endif
// This implementation works on Comeau and GCC, all the way back to
// 2.95
namespace boost { namespace concepts {
template <class ModelFn>
struct requirement_;
namespace detail
{
template <void(*)()> struct instantiate {};
}
template <class Model>
struct requirement
{
static void failed() { ((Model*)0)->~Model(); }
};
struct failed {};
template <class Model>
struct requirement<failed ************ Model::************>
{
static void failed() { ((Model*)0)->~Model(); }
};
# ifdef BOOST_OLD_CONCEPT_SUPPORT
template <class Model>
struct constraint
{
static void failed() { ((Model*)0)->constraints(); }
};
template <class Model>
struct requirement_<void(*)(Model)>
: boost::conditional<
concepts::not_satisfied<Model>::value
, constraint<Model>
, requirement<failed ************ Model::************>
>::type
{};
# else
// For GCC-2.x, these can't have exactly the same name
template <class Model>
struct requirement_<void(*)(Model)>
: requirement<failed ************ Model::************>
{};
# endif
# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr ) \
typedef ::boost::concepts::detail::instantiate< \
&::boost::concepts::requirement_<ModelFnPtr>::failed> \
BOOST_PP_CAT(boost_concept_check,__LINE__) \
BOOST_ATTRIBUTE_UNUSED
}}
#endif // BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP

50
3rdparty/boost/boost/concept/detail/has_constraints.hpp vendored
View File

@ -1,50 +0,0 @@
// Copyright David Abrahams 2006. 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_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
# define BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
# include <boost/type_traits/integral_constant.hpp>
# include <boost/config/workaround.hpp>
# include <boost/concept/detail/backward_compatibility.hpp>
namespace boost { namespace concepts {
namespace detail
{
// Here we implement the metafunction that detects whether a
// constraints metafunction exists
typedef char yes;
typedef char (&no)[2];
template <class Model, void (Model::*)()>
struct wrap_constraints {};
#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580) || defined(__CUDACC__)
// Work around the following bogus error in Sun Studio 11, by
// turning off the has_constraints function entirely:
// Error: complex expression not allowed in dependent template
// argument expression
inline no has_constraints_(...);
#else
template <class Model>
inline yes has_constraints_(Model*, wrap_constraints<Model,&Model::constraints>* = 0);
inline no has_constraints_(...);
#endif
}
// This would be called "detail::has_constraints," but it has a strong
// tendency to show up in error messages.
template <class Model>
struct not_satisfied
{
BOOST_STATIC_CONSTANT(
bool
, value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes) );
typedef boost::integral_constant<bool, value> type;
};
}} // namespace boost::concepts::detail
#endif // BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP

123
3rdparty/boost/boost/concept/detail/msvc.hpp vendored
View File

@ -1,123 +0,0 @@
// Copyright David Abrahams 2006. 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_CONCEPT_CHECK_MSVC_DWA2006429_HPP
# define BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
# include <boost/preprocessor/cat.hpp>
# include <boost/concept/detail/backward_compatibility.hpp>
# include <boost/config.hpp>
# ifdef BOOST_OLD_CONCEPT_SUPPORT
# include <boost/concept/detail/has_constraints.hpp>
# include <boost/type_traits/conditional.hpp>
# endif
# ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable:4100)
# endif
namespace boost { namespace concepts {
template <class Model>
struct check
{
virtual void failed(Model* x)
{
x->~Model();
}
};
# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
struct failed {};
template <class Model>
struct check<failed ************ Model::************>
{
virtual void failed(Model* x)
{
x->~Model();
}
};
# endif
# ifdef BOOST_OLD_CONCEPT_SUPPORT
namespace detail
{
// No need for a virtual function here, since evaluating
// not_satisfied below will have already instantiated the
// constraints() member.
struct constraint {};
}
template <class Model>
struct require
: boost::conditional<
not_satisfied<Model>::value
, detail::constraint
# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
, check<Model>
# else
, check<failed ************ Model::************>
# endif
>::type
{};
# else
template <class Model>
struct require
# ifndef BOOST_NO_PARTIAL_SPECIALIZATION
: check<Model>
# else
: check<failed ************ Model::************>
# endif
{};
# endif
# if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
//
// The iterator library sees some really strange errors unless we
// do things this way.
//
template <class Model>
struct require<void(*)(Model)>
{
virtual void failed(Model*)
{
require<Model>();
}
};
# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr ) \
enum \
{ \
BOOST_PP_CAT(boost_concept_check,__LINE__) = \
sizeof(::boost::concepts::require<ModelFnPtr>) \
}
# else // Not vc-7.1
template <class Model>
require<Model>
require_(void(*)(Model));
# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr ) \
enum \
{ \
BOOST_PP_CAT(boost_concept_check,__LINE__) = \
sizeof(::boost::concepts::require_((ModelFnPtr)0)) \
}
# endif
}}
# ifdef BOOST_MSVC
# pragma warning(pop)
# endif
#endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP

36
3rdparty/boost/boost/concept/usage.hpp vendored
View File

@ -1,36 +0,0 @@
// Copyright David Abrahams 2006. 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_CONCEPT_USAGE_DWA2006919_HPP
# define BOOST_CONCEPT_USAGE_DWA2006919_HPP
# include <boost/concept/assert.hpp>
# include <boost/config/workaround.hpp>
# include <boost/concept/detail/backward_compatibility.hpp>
namespace boost { namespace concepts {
template <class Model>
struct usage_requirements
{
~usage_requirements() { ((Model*)0)->~Model(); }
};
# if BOOST_WORKAROUND(__GNUC__, <= 3)
# define BOOST_CONCEPT_USAGE(model) \
model(); /* at least 2.96 and 3.4.3 both need this :( */ \
BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements<model>)); \
~model()
# else
# define BOOST_CONCEPT_USAGE(model) \
BOOST_CONCEPT_ASSERT((boost::concepts::usage_requirements<model>)); \
~model()
# endif
}} // namespace boost::concepts
#endif // BOOST_CONCEPT_USAGE_DWA2006919_HPP

1082
3rdparty/boost/boost/concept_check.hpp vendored
View File

File diff suppressed because it is too large Load Diff

301
3rdparty/boost/boost/container/container_fwd.hpp vendored
View File

@ -1,301 +0,0 @@
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2005-2014. 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)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP
#define BOOST_CONTAINER_CONTAINER_FWD_HPP
#ifndef BOOST_CONFIG_HPP
# include <boost/config.hpp>
#endif
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
//! \file
//! This header file forward declares the following containers:
//! - boost::container::vector
//! - boost::container::stable_vector
//! - boost::container::static_vector
//! - boost::container::small_vector_base
//! - boost::container::small_vector
//! - boost::container::slist
//! - boost::container::list
//! - boost::container::set
//! - boost::container::multiset
//! - boost::container::map
//! - boost::container::multimap
//! - boost::container::flat_set
//! - boost::container::flat_multiset
//! - boost::container::flat_map
//! - boost::container::flat_multimap
//! - boost::container::basic_string
//! - boost::container::string
//! - boost::container::wstring
//!
//! Forward declares the following allocators:
//! - boost::container::allocator
//! - boost::container::node_allocator
//! - boost::container::adaptive_pool
//!
//! Forward declares the following polymorphic resource classes:
//! - boost::container::pmr::memory_resource
//! - boost::container::pmr::polymorphic_allocator
//! - boost::container::pmr::monotonic_buffer_resource
//! - boost::container::pmr::pool_options
//! - boost::container::pmr::unsynchronized_pool_resource
//! - boost::container::pmr::synchronized_pool_resource
//!
//! And finally it defines the following types
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
//Std forward declarations
#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
#include <boost/container/detail/std_fwd.hpp>
#endif
namespace boost{
namespace intrusive{
namespace detail{
//Create namespace to avoid compilation errors
}}}
namespace boost{ namespace container{ namespace dtl{
namespace bi = boost::intrusive;
namespace bid = boost::intrusive::detail;
}}}
namespace boost{ namespace container{ namespace pmr{
namespace bi = boost::intrusive;
namespace bid = boost::intrusive::detail;
}}}
#include <cstddef>
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
//////////////////////////////////////////////////////////////////////////////
// Containers
//////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace container {
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
template<class T1, class T2>
struct pair;
template<class T>
class new_allocator;
template <class T
,class Allocator = void
,class Options = void>
class vector;
template <class T
,class Allocator = void >
class stable_vector;
template < class T
, std::size_t Capacity
, class Options = void>
class static_vector;
template < class T
, class Allocator = void
, class Options = void >
class small_vector_base;
template < class T
, std::size_t N
, class Allocator = void
, class Options = void >
class small_vector;
template <class T
,class Allocator = void
,class Options = void>
class deque;
template <class T
,class Allocator = void >
class list;
template <class T
,class Allocator = void >
class slist;
template <class Key
,class Compare = std::less<Key>
,class Allocator = void
,class Options = void>
class set;
template <class Key
,class Compare = std::less<Key>
,class Allocator = void
,class Options = void >
class multiset;
template <class Key
,class T
,class Compare = std::less<Key>
,class Allocator = void
,class Options = void >
class map;
template <class Key
,class T
,class Compare = std::less<Key>
,class Allocator = void
,class Options = void >
class multimap;
template <class Key
,class Compare = std::less<Key>
,class Allocator = void >
class flat_set;
template <class Key
,class Compare = std::less<Key>
,class Allocator = void >
class flat_multiset;
template <class Key
,class T
,class Compare = std::less<Key>
,class Allocator = void >
class flat_map;
template <class Key
,class T
,class Compare = std::less<Key>
,class Allocator = void >
class flat_multimap;
template <class CharT
,class Traits = std::char_traits<CharT>
,class Allocator = void >
class basic_string;
typedef basic_string <char> string;
typedef basic_string<wchar_t> wstring;
static const std::size_t ADP_nodes_per_block = 256u;
static const std::size_t ADP_max_free_blocks = 2u;
static const std::size_t ADP_overhead_percent = 1u;
static const std::size_t ADP_only_alignment = 0u;
template < class T
, std::size_t NodesPerBlock = ADP_nodes_per_block
, std::size_t MaxFreeBlocks = ADP_max_free_blocks
, std::size_t OverheadPercent = ADP_overhead_percent
, unsigned Version = 2
>
class adaptive_pool;
template < class T
, unsigned Version = 2
, unsigned int AllocationDisableMask = 0>
class allocator;
static const std::size_t NodeAlloc_nodes_per_block = 256u;
template
< class T
, std::size_t NodesPerBlock = NodeAlloc_nodes_per_block
, std::size_t Version = 2>
class node_allocator;
namespace pmr {
class memory_resource;
template<class T>
class polymorphic_allocator;
class monotonic_buffer_resource;
struct pool_options;
template <class Allocator>
class resource_adaptor_imp;
class unsynchronized_pool_resource;
class synchronized_pool_resource;
} //namespace pmr {
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
//! Type used to tag that the input range is
//! guaranteed to be ordered
struct ordered_range_t
{};
//! Value used to tag that the input range is
//! guaranteed to be ordered
static const ordered_range_t ordered_range = ordered_range_t();
//! Type used to tag that the input range is
//! guaranteed to be ordered and unique
struct ordered_unique_range_t
: public ordered_range_t
{};
//! Value used to tag that the input range is
//! guaranteed to be ordered and unique
static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();
//! Type used to tag that the inserted values
//! should be default initialized
struct default_init_t
{};
//! Value used to tag that the inserted values
//! should be default initialized
static const default_init_t default_init = default_init_t();
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
//! Type used to tag that the inserted values
//! should be value initialized
struct value_init_t
{};
//! Value used to tag that the inserted values
//! should be value initialized
static const value_init_t value_init = value_init_t();
namespace container_detail_really_deep_namespace {
//Otherwise, gcc issues a warning of previously defined
//anonymous_instance and unique_instance
struct dummy
{
dummy()
{
(void)ordered_range;
(void)ordered_unique_range;
(void)default_init;
}
};
} //detail_really_deep_namespace {
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}} //namespace boost { namespace container {
#endif //#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP

59
3rdparty/boost/boost/container/detail/std_fwd.hpp vendored
View File

@ -1,59 +0,0 @@
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2014-2014. 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)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
#define BOOST_CONTAINER_DETAIL_STD_FWD_HPP
#ifndef BOOST_CONFIG_HPP
# include <boost/config.hpp>
#endif
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
//////////////////////////////////////////////////////////////////////////////
// Standard predeclarations
//////////////////////////////////////////////////////////////////////////////
#include <boost/move/detail/std_ns_begin.hpp>
BOOST_MOVE_STD_NS_BEG
template<class T>
class allocator;
template<class T>
struct less;
template<class T>
struct equal_to;
template<class T1, class T2>
struct pair;
template<class T>
struct char_traits;
struct input_iterator_tag;
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;
template<class Container>
class insert_iterator;
struct allocator_arg_t;
struct piecewise_construct_t;
BOOST_MOVE_STD_NS_END
#include <boost/move/detail/std_ns_end.hpp>
#endif //#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP

139
3rdparty/boost/boost/detail/basic_pointerbuf.hpp vendored
View File

@ -1,139 +0,0 @@
//-----------------------------------------------------------------------------
// boost detail/templated_streams.hpp header file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
// Copyright (c) 2013 John Maddock, Antony Polukhin
//
//
// 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_DETAIL_BASIC_POINTERBUF_HPP
#define BOOST_DETAIL_BASIC_POINTERBUF_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
#include "boost/config.hpp"
#include <streambuf>
namespace boost { namespace detail {
//
// class basic_pointerbuf:
// acts as a stream buffer which wraps around a pair of pointers:
//
template <class charT, class BufferT >
class basic_pointerbuf : public BufferT {
protected:
typedef BufferT base_type;
typedef basic_pointerbuf<charT, BufferT> this_type;
typedef typename base_type::int_type int_type;
typedef typename base_type::char_type char_type;
typedef typename base_type::pos_type pos_type;
typedef ::std::streamsize streamsize;
typedef typename base_type::off_type off_type;
public:
basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); }
const charT* getnext() { return this->gptr(); }
#ifndef BOOST_NO_USING_TEMPLATE
using base_type::pptr;
using base_type::pbase;
#else
charT* pptr() const { return base_type::pptr(); }
charT* pbase() const { return base_type::pbase(); }
#endif
protected:
// VC mistakenly assumes that `setbuf` and other functions are not referenced.
// Marking those functions with `inline` suppresses the warnings.
// There must be no harm from marking virtual functions as inline: inline virtual
// call can be inlined ONLY when the compiler knows the "exact class".
inline base_type* setbuf(char_type* s, streamsize n);
inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
private:
basic_pointerbuf& operator=(const basic_pointerbuf&);
basic_pointerbuf(const basic_pointerbuf&);
};
template<class charT, class BufferT>
BufferT*
basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
{
this->setg(s, s, s + n);
return this;
}
template<class charT, class BufferT>
typename basic_pointerbuf<charT, BufferT>::pos_type
basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
{
typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
if(which & ::std::ios_base::out)
return pos_type(off_type(-1));
std::ptrdiff_t size = this->egptr() - this->eback();
std::ptrdiff_t pos = this->gptr() - this->eback();
charT* g = this->eback();
switch(static_cast<cast_type>(way))
{
case ::std::ios_base::beg:
if((off < 0) || (off > size))
return pos_type(off_type(-1));
else
this->setg(g, g + off, g + size);
break;
case ::std::ios_base::end:
if((off < 0) || (off > size))
return pos_type(off_type(-1));
else
this->setg(g, g + size - off, g + size);
break;
case ::std::ios_base::cur:
{
std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
if((newpos < 0) || (newpos > size))
return pos_type(off_type(-1));
else
this->setg(g, g + newpos, g + size);
break;
}
default: ;
}
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable:4244)
#endif
return static_cast<pos_type>(this->gptr() - this->eback());
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
}
template<class charT, class BufferT>
typename basic_pointerbuf<charT, BufferT>::pos_type
basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
{
if(which & ::std::ios_base::out)
return pos_type(off_type(-1));
off_type size = static_cast<off_type>(this->egptr() - this->eback());
charT* g = this->eback();
if(off_type(sp) <= size)
{
this->setg(g, g + off_type(sp), g + size);
}
return pos_type(off_type(-1));
}
}} // namespace boost::detail
#endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP

101
3rdparty/boost/boost/detail/fenv.hpp vendored
View File

@ -1,101 +0,0 @@
/*=============================================================================
Copyright (c) 2010 Bryce Lelbach
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)
=============================================================================*/
#include <boost/config.hpp>
#if defined(BOOST_NO_FENV_H)
#error This platform does not have a floating point environment
#endif
#if !defined(BOOST_DETAIL_FENV_HPP)
#define BOOST_DETAIL_FENV_HPP
/* If we're using clang + glibc, we have to get hacky.
* See http://llvm.org/bugs/show_bug.cgi?id=6907 */
#if defined(__clang__) && (__clang_major__ < 3) && \
defined(__GNU_LIBRARY__) && /* up to version 5 */ \
defined(__GLIBC__) && /* version 6 + */ \
!defined(_FENV_H)
#define _FENV_H
#include <features.h>
#include <bits/fenv.h>
extern "C" {
extern int fegetexceptflag (fexcept_t*, int) __THROW;
extern int fesetexceptflag (__const fexcept_t*, int) __THROW;
extern int feclearexcept (int) __THROW;
extern int feraiseexcept (int) __THROW;
extern int fetestexcept (int) __THROW;
extern int fegetround (void) __THROW;
extern int fesetround (int) __THROW;
extern int fegetenv (fenv_t*) __THROW;
extern int fesetenv (__const fenv_t*) __THROW;
extern int feupdateenv (__const fenv_t*) __THROW;
extern int feholdexcept (fenv_t*) __THROW;
#ifdef __USE_GNU
extern int feenableexcept (int) __THROW;
extern int fedisableexcept (int) __THROW;
extern int fegetexcept (void) __THROW;
#endif
}
namespace std { namespace tr1 {
using ::fenv_t;
using ::fexcept_t;
using ::fegetexceptflag;
using ::fesetexceptflag;
using ::feclearexcept;
using ::feraiseexcept;
using ::fetestexcept;
using ::fegetround;
using ::fesetround;
using ::fegetenv;
using ::fesetenv;
using ::feupdateenv;
using ::feholdexcept;
} }
#elif defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408
// MinGW (32-bit) has a bug in mingw32/bits/c++config.h, it does not define _GLIBCXX_HAVE_FENV_H,
// which prevents the C fenv.h header contents to be included in the C++ wrapper header fenv.h. This is at least
// the case with gcc 4.8.1 packages tested so far, up to 4.8.1-4. Note that there is no issue with
// MinGW-w64.
// To work around the bug we avoid including the C++ wrapper header and include the C header directly
// and import all relevant symbols into std:: ourselves.
#include <../include/fenv.h>
namespace std {
using ::fenv_t;
using ::fexcept_t;
using ::fegetexceptflag;
using ::fesetexceptflag;
using ::feclearexcept;
using ::feraiseexcept;
using ::fetestexcept;
using ::fegetround;
using ::fesetround;
using ::fegetenv;
using ::fesetenv;
using ::feupdateenv;
using ::feholdexcept;
}
#else /* if we're not using GNU's C stdlib, fenv.h should work with clang */
#if defined(__SUNPRO_CC) /* lol suncc */
#include <stdio.h>
#endif
#include <fenv.h>
#endif
#endif /* BOOST_DETAIL_FENV_HPP */

185
3rdparty/boost/boost/detail/lcast_precision.hpp vendored
View File

@ -1,185 +0,0 @@
// Copyright Alexander Nasonov & Paul A. Bristow 2006.
// Use, modification and distribution are 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)
#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
#include <climits>
#include <ios>
#include <limits>
#include <boost/config.hpp>
#include <boost/integer_traits.hpp>
#ifndef BOOST_NO_IS_ABSTRACT
// Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_abstract.hpp>
#endif
#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
(defined(BOOST_MSVC) && (BOOST_MSVC<1310))
#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
#endif
#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
#include <boost/assert.hpp>
#else
#include <boost/static_assert.hpp>
#endif
namespace boost { namespace detail {
class lcast_abstract_stub {};
#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
// Calculate an argument to pass to std::ios_base::precision from
// lexical_cast. See alternative implementation for broken standard
// libraries in lcast_get_precision below. Keep them in sync, please.
template<class T>
struct lcast_precision
{
#ifdef BOOST_NO_IS_ABSTRACT
typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
#else
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::is_abstract<T>::value
, std::numeric_limits<lcast_abstract_stub>
, std::numeric_limits<T>
>::type limits;
#endif
BOOST_STATIC_CONSTANT(bool, use_default_precision =
!limits::is_specialized || limits::is_exact
);
BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
!use_default_precision &&
limits::radix == 2 && limits::digits > 0
);
BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
!use_default_precision &&
limits::radix == 10 && limits::digits10 > 0
);
BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
boost::integer_traits<std::streamsize>::const_max
);
BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
BOOST_STATIC_ASSERT(!is_specialized_dec ||
precision_dec <= streamsize_max + 0UL
);
BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
2UL + limits::digits * 30103UL / 100000UL
);
BOOST_STATIC_ASSERT(!is_specialized_bin ||
(limits::digits + 0UL < ULONG_MAX / 30103UL &&
precision_bin > limits::digits10 + 0UL &&
precision_bin <= streamsize_max + 0UL)
);
BOOST_STATIC_CONSTANT(std::streamsize, value =
is_specialized_bin ? precision_bin
: is_specialized_dec ? precision_dec : 6
);
};
#endif
template<class T>
inline std::streamsize lcast_get_precision(T* = 0)
{
#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
return lcast_precision<T>::value;
#else // Follow lcast_precision algorithm at run-time:
#ifdef BOOST_NO_IS_ABSTRACT
typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
#else
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::is_abstract<T>::value
, std::numeric_limits<lcast_abstract_stub>
, std::numeric_limits<T>
>::type limits;
#endif
bool const use_default_precision =
!limits::is_specialized || limits::is_exact;
if(!use_default_precision)
{ // Includes all built-in floating-point types, float, double ...
// and UDT types for which digits (significand bits) is defined (not zero)
bool const is_specialized_bin =
limits::radix == 2 && limits::digits > 0;
bool const is_specialized_dec =
limits::radix == 10 && limits::digits10 > 0;
std::streamsize const streamsize_max =
(boost::integer_traits<std::streamsize>::max)();
(void)streamsize_max;
if(is_specialized_bin)
{ // Floating-point types with
// limits::digits defined by the specialization.
unsigned long const digits = limits::digits;
unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
// unsigned long is selected because it is at least 32-bits
// and thus ULONG_MAX / 30103UL is big enough for all types.
BOOST_ASSERT(
digits < ULONG_MAX / 30103UL &&
precision > limits::digits10 + 0UL &&
precision <= streamsize_max + 0UL
);
return precision;
}
else if(is_specialized_dec)
{ // Decimal Floating-point type, most likely a User Defined Type
// rather than a real floating-point hardware type.
unsigned int const precision = limits::digits10 + 1U;
BOOST_ASSERT(precision <= streamsize_max + 0UL);
return precision;
}
}
// Integral type (for which precision has no effect)
// or type T for which limits is NOT specialized,
// so assume stream precision remains the default 6 decimal digits.
// Warning: if your User-defined Floating-point type T is NOT specialized,
// then you may lose accuracy by only using 6 decimal digits.
// To avoid this, you need to specialize T with either
// radix == 2 and digits == the number of significand bits,
// OR
// radix = 10 and digits10 == the number of decimal digits.
return 6;
#endif
}
template<class T>
inline void lcast_set_precision(std::ios_base& stream, T*)
{
stream.precision(lcast_get_precision<T>());
}
template<class Source, class Target>
inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
{
std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
stream.precision(s > t ? s : t);
}
}}
#endif // BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED

84
3rdparty/boost/boost/iterator/advance.hpp vendored
View File

@ -1,84 +0,0 @@
// Copyright (C) 2017 Michel Morin.
//
// 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_ITERATOR_ADVANCE_HPP
#define BOOST_ITERATOR_ADVANCE_HPP
#include <boost/config.hpp>
#include <boost/iterator/iterator_categories.hpp>
namespace boost {
namespace iterators {
namespace detail {
template <typename InputIterator, typename Distance>
inline BOOST_CXX14_CONSTEXPR void
advance_impl(
InputIterator& it
, Distance n
, incrementable_traversal_tag
)
{
while (n > 0) {
++it;
--n;
}
}
template <typename BidirectionalIterator, typename Distance>
inline BOOST_CXX14_CONSTEXPR void
advance_impl(
BidirectionalIterator& it
, Distance n
, bidirectional_traversal_tag
)
{
if (n >= 0) {
while (n > 0) {
++it;
--n;
}
}
else {
while (n < 0) {
--it;
++n;
}
}
}
template <typename RandomAccessIterator, typename Distance>
inline BOOST_CXX14_CONSTEXPR void
advance_impl(
RandomAccessIterator& it
, Distance n
, random_access_traversal_tag
)
{
it += n;
}
}
namespace advance_adl_barrier {
template <typename InputIterator, typename Distance>
inline BOOST_CXX14_CONSTEXPR void
advance(InputIterator& it, Distance n)
{
detail::advance_impl(
it, n, typename iterator_traversal<InputIterator>::type()
);
}
}
using namespace advance_adl_barrier;
} // namespace iterators
using namespace iterators::advance_adl_barrier;
} // namespace boost
#endif

65
3rdparty/boost/boost/iterator/distance.hpp vendored
View File

@ -1,65 +0,0 @@
// Copyright (C) 2017 Michel Morin.
//
// 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_ITERATOR_DISTANCE_HPP
#define BOOST_ITERATOR_DISTANCE_HPP
#include <boost/config.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_traits.hpp>
namespace boost {
namespace iterators {
namespace detail {
template <typename SinglePassIterator>
inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
distance_impl(
SinglePassIterator first
, SinglePassIterator last
, single_pass_traversal_tag
)
{
typename iterator_difference<SinglePassIterator>::type n = 0;
while (first != last) {
++first;
++n;
}
return n;
}
template <typename RandomAccessIterator>
inline BOOST_CXX14_CONSTEXPR typename iterator_difference<RandomAccessIterator>::type
distance_impl(
RandomAccessIterator first
, RandomAccessIterator last
, random_access_traversal_tag
)
{
return last - first;
}
}
namespace distance_adl_barrier {
template <typename SinglePassIterator>
inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
distance(SinglePassIterator first, SinglePassIterator last)
{
return detail::distance_impl(
first, last, typename iterator_traversal<SinglePassIterator>::type()
);
}
}
using namespace distance_adl_barrier;
} // namespace iterators
using namespace iterators::distance_adl_barrier;
} // namespace boost
#endif

273
3rdparty/boost/boost/iterator/iterator_concepts.hpp vendored
View File

@ -1,273 +0,0 @@
// (C) Copyright Jeremy Siek 2002.
// 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_ITERATOR_CONCEPTS_HPP
#define BOOST_ITERATOR_CONCEPTS_HPP
#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/or.hpp>
#include <boost/static_assert.hpp>
// Use boost/limits to work around missing limits headers on some compilers
#include <boost/limits.hpp>
#include <boost/config.hpp>
#include <algorithm>
#include <iterator>
#include <boost/concept/detail/concept_def.hpp>
namespace boost_concepts
{
// Used a different namespace here (instead of "boost") so that the
// concept descriptions do not take for granted the names in
// namespace boost.
//===========================================================================
// Iterator Access Concepts
BOOST_concept(ReadableIterator,(Iterator))
: boost::Assignable<Iterator>
, boost::CopyConstructible<Iterator>
{
typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference reference;
BOOST_CONCEPT_USAGE(ReadableIterator)
{
value_type v = *i;
boost::ignore_unused_variable_warning(v);
}
private:
Iterator i;
};
template <
typename Iterator
, typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
>
struct WritableIterator
: boost::CopyConstructible<Iterator>
{
BOOST_CONCEPT_USAGE(WritableIterator)
{
*i = v;
}
private:
ValueType v;
Iterator i;
};
template <
typename Iterator
, typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
>
struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
BOOST_concept(SwappableIterator,(Iterator))
{
BOOST_CONCEPT_USAGE(SwappableIterator)
{
std::iter_swap(i1, i2);
}
private:
Iterator i1;
Iterator i2;
};
BOOST_concept(LvalueIterator,(Iterator))
{
typedef typename std::iterator_traits<Iterator>::value_type value_type;
BOOST_CONCEPT_USAGE(LvalueIterator)
{
value_type& r = const_cast<value_type&>(*i);
boost::ignore_unused_variable_warning(r);
}
private:
Iterator i;
};
//===========================================================================
// Iterator Traversal Concepts
BOOST_concept(IncrementableIterator,(Iterator))
: boost::Assignable<Iterator>
, boost::CopyConstructible<Iterator>
{
typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
BOOST_CONCEPT_ASSERT((
boost::Convertible<
traversal_category
, boost::incrementable_traversal_tag
>));
BOOST_CONCEPT_USAGE(IncrementableIterator)
{
++i;
(void)i++;
}
private:
Iterator i;
};
BOOST_concept(SinglePassIterator,(Iterator))
: IncrementableIterator<Iterator>
, boost::EqualityComparable<Iterator>
{
BOOST_CONCEPT_ASSERT((
boost::Convertible<
BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category
, boost::single_pass_traversal_tag
> ));
};
BOOST_concept(ForwardTraversal,(Iterator))
: SinglePassIterator<Iterator>
, boost::DefaultConstructible<Iterator>
{
typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
BOOST_CONCEPT_ASSERT((
boost::Convertible<
BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category
, boost::forward_traversal_tag
> ));
};
BOOST_concept(BidirectionalTraversal,(Iterator))
: ForwardTraversal<Iterator>
{
BOOST_CONCEPT_ASSERT((
boost::Convertible<
BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category
, boost::bidirectional_traversal_tag
> ));
BOOST_CONCEPT_USAGE(BidirectionalTraversal)
{
--i;
(void)i--;
}
private:
Iterator i;
};
BOOST_concept(RandomAccessTraversal,(Iterator))
: BidirectionalTraversal<Iterator>
{
BOOST_CONCEPT_ASSERT((
boost::Convertible<
BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category
, boost::random_access_traversal_tag
> ));
BOOST_CONCEPT_USAGE(RandomAccessTraversal)
{
i += n;
i = i + n;
i = n + i;
i -= n;
i = i - n;
n = i - j;
}
private:
typename BidirectionalTraversal<Iterator>::difference_type n;
Iterator i, j;
};
//===========================================================================
// Iterator Interoperability
namespace detail
{
template <typename Iterator1, typename Iterator2>
void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
{
bool b;
b = i1 == i2;
b = i1 != i2;
b = i2 == i1;
b = i2 != i1;
boost::ignore_unused_variable_warning(b);
}
template <typename Iterator1, typename Iterator2>
void interop_rand_access_constraints(
Iterator1 const& i1, Iterator2 const& i2,
boost::random_access_traversal_tag, boost::random_access_traversal_tag)
{
bool b;
typename std::iterator_traits<Iterator2>::difference_type n;
b = i1 < i2;
b = i1 <= i2;
b = i1 > i2;
b = i1 >= i2;
n = i1 - i2;
b = i2 < i1;
b = i2 <= i1;
b = i2 > i1;
b = i2 >= i1;
n = i2 - i1;
boost::ignore_unused_variable_warning(b);
boost::ignore_unused_variable_warning(n);
}
template <typename Iterator1, typename Iterator2>
void interop_rand_access_constraints(
Iterator1 const&, Iterator2 const&,
boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
{ }
} // namespace detail
BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
{
private:
typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;
typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;
public:
BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
BOOST_CONCEPT_USAGE(InteroperableIterator)
{
detail::interop_single_pass_constraints(i, ci);
detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
ci = i;
}
private:
Iterator i;
ConstIterator ci;
};
} // namespace boost_concepts
#include <boost/concept/detail/concept_undef.hpp>
#endif // BOOST_ITERATOR_CONCEPTS_HPP

105
3rdparty/boost/boost/lexical_cast.hpp vendored
View File

@ -1,105 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_INCLUDED
#define BOOST_LEXICAL_CAST_INCLUDED
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
#define BOOST_LCAST_NO_WCHAR_T
#endif
#include <boost/range/iterator_range_core.hpp>
#include <boost/lexical_cast/bad_lexical_cast.hpp>
#include <boost/lexical_cast/try_lexical_convert.hpp>
namespace boost
{
template <typename Target, typename Source>
inline Target lexical_cast(const Source &arg)
{
Target result = Target();
if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
boost::conversion::detail::throw_bad_cast<Source, Target>();
}
return result;
}
template <typename Target>
inline Target lexical_cast(const char* chars, std::size_t count)
{
return ::boost::lexical_cast<Target>(
::boost::iterator_range<const char*>(chars, chars + count)
);
}
template <typename Target>
inline Target lexical_cast(const unsigned char* chars, std::size_t count)
{
return ::boost::lexical_cast<Target>(
::boost::iterator_range<const unsigned char*>(chars, chars + count)
);
}
template <typename Target>
inline Target lexical_cast(const signed char* chars, std::size_t count)
{
return ::boost::lexical_cast<Target>(
::boost::iterator_range<const signed char*>(chars, chars + count)
);
}
#ifndef BOOST_LCAST_NO_WCHAR_T
template <typename Target>
inline Target lexical_cast(const wchar_t* chars, std::size_t count)
{
return ::boost::lexical_cast<Target>(
::boost::iterator_range<const wchar_t*>(chars, chars + count)
);
}
#endif
#ifndef BOOST_NO_CXX11_CHAR16_T
template <typename Target>
inline Target lexical_cast(const char16_t* chars, std::size_t count)
{
return ::boost::lexical_cast<Target>(
::boost::iterator_range<const char16_t*>(chars, chars + count)
);
}
#endif
#ifndef BOOST_NO_CXX11_CHAR32_T
template <typename Target>
inline Target lexical_cast(const char32_t* chars, std::size_t count)
{
return ::boost::lexical_cast<Target>(
::boost::iterator_range<const char32_t*>(chars, chars + count)
);
}
#endif
} // namespace boost
#undef BOOST_LCAST_NO_WCHAR_T
#endif // BOOST_LEXICAL_CAST_INCLUDED

101
3rdparty/boost/boost/lexical_cast/bad_lexical_cast.hpp vendored
View File

@ -1,101 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
#define BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#include <typeinfo>
#include <exception>
#include <boost/throw_exception.hpp>
namespace boost
{
// exception used to indicate runtime lexical_cast failure
class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
// workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0
#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
public std::exception
#else
public std::bad_cast
#endif
#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 )
// under bcc32 5.5.1 bad_cast doesn't derive from exception
, public std::exception
#endif
{
public:
bad_lexical_cast() BOOST_NOEXCEPT
#ifndef BOOST_NO_TYPEID
: source(&typeid(void)), target(&typeid(void))
#endif
{}
virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW {
return "bad lexical cast: "
"source type value could not be interpreted as target";
}
virtual ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW
{}
#ifndef BOOST_NO_TYPEID
bad_lexical_cast(
const std::type_info &source_type_arg,
const std::type_info &target_type_arg) BOOST_NOEXCEPT
: source(&source_type_arg), target(&target_type_arg)
{}
const std::type_info &source_type() const BOOST_NOEXCEPT {
return *source;
}
const std::type_info &target_type() const BOOST_NOEXCEPT {
return *target;
}
private:
const std::type_info *source;
const std::type_info *target;
#endif
};
namespace conversion { namespace detail {
#ifdef BOOST_NO_TYPEID
template <class S, class T>
inline void throw_bad_cast() {
boost::throw_exception(bad_lexical_cast());
}
#else
template <class S, class T>
inline void throw_bad_cast() {
boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
}
#endif
}} // namespace conversion::detail
} // namespace boost
#endif // BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP

498
3rdparty/boost/boost/lexical_cast/detail/converter_lexical.hpp vendored
View File

@ -1,498 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
#define BOOST_LCAST_NO_WCHAR_T
#endif
#include <cstddef>
#include <string>
#include <boost/limits.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/type_identity.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_float.hpp>
#include <boost/type_traits/has_left_shift.hpp>
#include <boost/type_traits/has_right_shift.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/lcast_precision.hpp>
#include <boost/lexical_cast/detail/widest_char.hpp>
#include <boost/lexical_cast/detail/is_character.hpp>
#ifndef BOOST_NO_CXX11_HDR_ARRAY
#include <array>
#endif
#include <boost/array.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/container/container_fwd.hpp>
#include <boost/lexical_cast/detail/converter_lexical_streams.hpp>
namespace boost {
namespace detail // normalize_single_byte_char<Char>
{
// Converts signed/unsigned char to char
template < class Char >
struct normalize_single_byte_char
{
typedef Char type;
};
template <>
struct normalize_single_byte_char< signed char >
{
typedef char type;
};
template <>
struct normalize_single_byte_char< unsigned char >
{
typedef char type;
};
}
namespace detail // deduce_character_type_later<T>
{
// Helper type, meaning that stram character for T must be deduced
// at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
template < class T > struct deduce_character_type_later {};
}
namespace detail // stream_char_common<T>
{
// Selectors to choose stream character type (common for Source and Target)
// Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
// Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
template < typename Type >
struct stream_char_common: public boost::conditional<
boost::detail::is_character< Type >::value,
Type,
boost::detail::deduce_character_type_later< Type >
> {};
template < typename Char >
struct stream_char_common< Char* >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< Char* >
> {};
template < typename Char >
struct stream_char_common< const Char* >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< const Char* >
> {};
template < typename Char >
struct stream_char_common< boost::iterator_range< Char* > >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
> {};
template < typename Char >
struct stream_char_common< boost::iterator_range< const Char* > >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
> {};
template < class Char, class Traits, class Alloc >
struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
{
typedef Char type;
};
template < class Char, class Traits, class Alloc >
struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
{
typedef Char type;
};
template < typename Char, std::size_t N >
struct stream_char_common< boost::array< Char, N > >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< boost::array< Char, N > >
> {};
template < typename Char, std::size_t N >
struct stream_char_common< boost::array< const Char, N > >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< boost::array< const Char, N > >
> {};
#ifndef BOOST_NO_CXX11_HDR_ARRAY
template < typename Char, std::size_t N >
struct stream_char_common< std::array<Char, N > >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< std::array< Char, N > >
> {};
template < typename Char, std::size_t N >
struct stream_char_common< std::array< const Char, N > >: public boost::conditional<
boost::detail::is_character< Char >::value,
Char,
boost::detail::deduce_character_type_later< std::array< const Char, N > >
> {};
#endif
#ifdef BOOST_HAS_INT128
template <> struct stream_char_common< boost::int128_type >: public boost::type_identity< char > {};
template <> struct stream_char_common< boost::uint128_type >: public boost::type_identity< char > {};
#endif
#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
template <>
struct stream_char_common< wchar_t >
{
typedef char type;
};
#endif
}
namespace detail // deduce_source_char_impl<T>
{
// If type T is `deduce_character_type_later` type, then tries to deduce
// character type using boost::has_left_shift<T> metafunction.
// Otherwise supplied type T is a character type, that must be normalized
// using normalize_single_byte_char<Char>.
// Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
template < class Char >
struct deduce_source_char_impl
{
typedef BOOST_DEDUCED_TYPENAME boost::detail::normalize_single_byte_char< Char >::type type;
};
template < class T >
struct deduce_source_char_impl< deduce_character_type_later< T > >
{
typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t;
#if defined(BOOST_LCAST_NO_WCHAR_T)
BOOST_STATIC_ASSERT_MSG((result_t::value),
"Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
typedef char type;
#else
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
result_t::value, char, wchar_t
>::type type;
BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value),
"Source type is neither std::ostream`able nor std::wostream`able");
#endif
};
}
namespace detail // deduce_target_char_impl<T>
{
// If type T is `deduce_character_type_later` type, then tries to deduce
// character type using boost::has_right_shift<T> metafunction.
// Otherwise supplied type T is a character type, that must be normalized
// using normalize_single_byte_char<Char>.
// Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
template < class Char >
struct deduce_target_char_impl
{
typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
};
template < class T >
struct deduce_target_char_impl< deduce_character_type_later<T> >
{
typedef boost::has_right_shift<std::basic_istream<char>, T > result_t;
#if defined(BOOST_LCAST_NO_WCHAR_T)
BOOST_STATIC_ASSERT_MSG((result_t::value),
"Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
typedef char type;
#else
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
result_t::value, char, wchar_t
>::type type;
BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
"Target type is neither std::istream`able nor std::wistream`able");
#endif
};
}
namespace detail // deduce_target_char<T> and deduce_source_char<T>
{
// We deduce stream character types in two stages.
//
// Stage 1 is common for Target and Source. At Stage 1 we get
// non normalized character type (may contain unsigned/signed char)
// or deduce_character_type_later<T> where T is the original type.
// Stage 1 is executed by stream_char_common<T>
//
// At Stage 2 we normalize character types or try to deduce character
// type using metafunctions.
// Stage 2 is executed by deduce_target_char_impl<T> and
// deduce_source_char_impl<T>
//
// deduce_target_char<T> and deduce_source_char<T> functions combine
// both stages
template < class T >
struct deduce_target_char
{
typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
typedef stage2_type type;
};
template < class T >
struct deduce_source_char
{
typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
typedef stage2_type type;
};
}
namespace detail // extract_char_traits template
{
// We are attempting to get char_traits<> from T
// template parameter. Otherwise we'll be using std::char_traits<Char>
template < class Char, class T >
struct extract_char_traits
: boost::false_type
{
typedef std::char_traits< Char > trait_t;
};
template < class Char, class Traits, class Alloc >
struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > >
: boost::true_type
{
typedef Traits trait_t;
};
template < class Char, class Traits, class Alloc>
struct extract_char_traits< Char, boost::container::basic_string< Char, Traits, Alloc > >
: boost::true_type
{
typedef Traits trait_t;
};
}
namespace detail // array_to_pointer_decay<T>
{
template<class T>
struct array_to_pointer_decay
{
typedef T type;
};
template<class T, std::size_t N>
struct array_to_pointer_decay<T[N]>
{
typedef const T * type;
};
}
namespace detail // lcast_src_length
{
// Return max. length of string representation of Source;
template< class Source, // Source type of lexical_cast.
class Enable = void // helper type
>
struct lcast_src_length
{
BOOST_STATIC_CONSTANT(std::size_t, value = 1);
};
// Helper for integral types.
// Notes on length calculation:
// Max length for 32bit int with grouping "\1" and thousands_sep ',':
// "-2,1,4,7,4,8,3,6,4,7"
// ^ - is_signed
// ^ - 1 digit not counted by digits10
// ^^^^^^^^^^^^^^^^^^ - digits10 * 2
//
// Constant is_specialized is used instead of constant 1
// to prevent buffer overflow in a rare case when
// <boost/limits.hpp> doesn't add missing specialization for
// numeric_limits<T> for some integral type T.
// When is_specialized is false, the whole expression is 0.
template <class Source>
struct lcast_src_length<
Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_integral<Source> >::type
>
{
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
BOOST_STATIC_CONSTANT(std::size_t, value =
std::numeric_limits<Source>::is_signed +
std::numeric_limits<Source>::is_specialized + /* == 1 */
std::numeric_limits<Source>::digits10 * 2
);
#else
BOOST_STATIC_CONSTANT(std::size_t, value = 156);
BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
#endif
};
// Helper for floating point types.
// -1.23456789e-123456
// ^ sign
// ^ leading digit
// ^ decimal point
// ^^^^^^^^ lcast_precision<Source>::value
// ^ "e"
// ^ exponent sign
// ^^^^^^ exponent (assumed 6 or less digits)
// sign + leading digit + decimal point + "e" + exponent sign == 5
template<class Source>
struct lcast_src_length<
Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_float<Source> >::type
>
{
#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
BOOST_STATIC_ASSERT(
std::numeric_limits<Source>::max_exponent10 <= 999999L &&
std::numeric_limits<Source>::min_exponent10 >= -999999L
);
BOOST_STATIC_CONSTANT(std::size_t, value =
5 + lcast_precision<Source>::value + 6
);
#else // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
BOOST_STATIC_CONSTANT(std::size_t, value = 156);
#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
};
}
namespace detail // lexical_cast_stream_traits<Source, Target>
{
template <class Source, class Target>
struct lexical_cast_stream_traits {
typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<src>::type no_cv_src;
typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t;
typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_target_char<Target>::type target_char_t;
typedef BOOST_DEDUCED_TYPENAME boost::detail::widest_char<
target_char_t, src_char_t
>::type char_type;
#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char16_t, src_char_t>::value
&& !boost::is_same<char16_t, target_char_t>::value),
"Your compiler does not have full support for char16_t" );
#endif
#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char32_t, src_char_t>::value
&& !boost::is_same<char32_t, target_char_t>::value),
"Your compiler does not have full support for char32_t" );
#endif
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::detail::extract_char_traits<char_type, Target>::value,
BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, Target>,
BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, no_cv_src>
>::type::trait_t traits;
typedef boost::integral_constant<
bool,
boost::is_same<char, src_char_t>::value && // source is not a wide character based type
(sizeof(char) != sizeof(target_char_t)) && // target type is based on wide character
(!(boost::detail::is_character<no_cv_src>::value))
> is_string_widening_required_t;
typedef boost::integral_constant<
bool,
!(boost::is_integral<no_cv_src>::value ||
boost::detail::is_character<
BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1
>::value // then we have no optimization for that type
)
> is_source_input_not_optimized_t;
// If we have an optimized conversion for
// Source, we do not need to construct stringbuf.
BOOST_STATIC_CONSTANT(bool, requires_stringbuf =
(is_string_widening_required_t::value || is_source_input_not_optimized_t::value)
);
typedef boost::detail::lcast_src_length<no_cv_src> len_t;
};
}
namespace detail
{
template<typename Target, typename Source>
struct lexical_converter_impl
{
typedef lexical_cast_stream_traits<Source, Target> stream_trait;
typedef detail::lexical_istream_limited_src<
BOOST_DEDUCED_TYPENAME stream_trait::char_type,
BOOST_DEDUCED_TYPENAME stream_trait::traits,
stream_trait::requires_stringbuf,
stream_trait::len_t::value + 1
> i_interpreter_type;
typedef detail::lexical_ostream_limited_src<
BOOST_DEDUCED_TYPENAME stream_trait::char_type,
BOOST_DEDUCED_TYPENAME stream_trait::traits
> o_interpreter_type;
static inline bool try_convert(const Source& arg, Target& result) {
i_interpreter_type i_interpreter;
// Disabling ADL, by directly specifying operators.
if (!(i_interpreter.operator <<(arg)))
return false;
o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend());
// Disabling ADL, by directly specifying operators.
if(!(out.operator >>(result)))
return false;
return true;
}
};
}
} // namespace boost
#undef BOOST_LCAST_NO_WCHAR_T
#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP

786
3rdparty/boost/boost/lexical_cast/detail/converter_lexical_streams.hpp vendored
View File

@ -1,786 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014, Nowember 2016
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
#define BOOST_LCAST_NO_WCHAR_T
#endif
#include <cstddef>
#include <string>
#include <cstring>
#include <cstdio>
#include <boost/limits.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>
#ifndef BOOST_NO_STD_LOCALE
# include <locale>
#else
# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
// Getting error at this point means, that your STL library is old/lame/misconfigured.
// If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
// but beware: lexical_cast will understand only 'C' locale delimeters and thousands
// separators.
# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
# error "boost::lexical_cast to use only 'C' locale during conversions."
# endif
#endif
#ifdef BOOST_NO_STRINGSTREAM
#include <strstream>
#else
#include <sstream>
#endif
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
#include <boost/lexical_cast/detail/lcast_unsigned_converters.hpp>
#include <boost/lexical_cast/detail/inf_nan.hpp>
#include <istream>
#ifndef BOOST_NO_CXX11_HDR_ARRAY
#include <array>
#endif
#include <boost/array.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_float.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/container/container_fwd.hpp>
#include <boost/integer.hpp>
#include <boost/detail/basic_pointerbuf.hpp>
#include <boost/noncopyable.hpp>
#ifndef BOOST_NO_CWCHAR
# include <cwchar>
#endif
namespace boost {
namespace detail // basic_unlockedbuf
{
// acts as a stream buffer which wraps around a pair of pointers
// and gives acces to internals
template <class BufferType, class CharT>
class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
public:
typedef basic_pointerbuf<CharT, BufferType> base_type;
typedef BOOST_DEDUCED_TYPENAME base_type::streamsize streamsize;
#ifndef BOOST_NO_USING_TEMPLATE
using base_type::pptr;
using base_type::pbase;
using base_type::setbuf;
#else
charT* pptr() const { return base_type::pptr(); }
charT* pbase() const { return base_type::pbase(); }
BufferType* setbuf(char_type* s, streamsize n) { return base_type::setbuf(s, n); }
#endif
};
}
namespace detail
{
struct do_not_construct_out_buffer_t{};
struct do_not_construct_out_stream_t{
do_not_construct_out_stream_t(do_not_construct_out_buffer_t*){}
};
template <class CharT, class Traits>
struct out_stream_helper_trait {
#if defined(BOOST_NO_STRINGSTREAM)
typedef std::ostream out_stream_t;
typedef basic_unlockedbuf<std::strstreambuf, char> stringbuffer_t;
#elif defined(BOOST_NO_STD_LOCALE)
typedef std::ostream out_stream_t;
typedef basic_unlockedbuf<std::stringbuf, char> stringbuffer_t;
typedef basic_unlockedbuf<std::streambuf, char> buffer_t;
#else
typedef std::basic_ostream<CharT, Traits> out_stream_t;
typedef basic_unlockedbuf<std::basic_stringbuf<CharT, Traits>, CharT> stringbuffer_t;
typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT> buffer_t;
#endif
};
}
namespace detail // optimized stream wrappers
{
template< class CharT // a result of widest_char transformation
, class Traits
, bool RequiresStringbuffer
, std::size_t CharacterBufferSize
>
class lexical_istream_limited_src: boost::noncopyable {
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
RequiresStringbuffer,
BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t,
do_not_construct_out_stream_t
>::type deduced_out_stream_t;
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
RequiresStringbuffer,
BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::stringbuffer_t,
do_not_construct_out_buffer_t
>::type deduced_out_buffer_t;
deduced_out_buffer_t out_buffer;
deduced_out_stream_t out_stream;
CharT buffer[CharacterBufferSize];
// After the `operator <<` finishes, `[start, finish)` is
// the range to output by `operator >>`
const CharT* start;
const CharT* finish;
public:
lexical_istream_limited_src() BOOST_NOEXCEPT
: out_buffer()
, out_stream(&out_buffer)
, start(buffer)
, finish(buffer + CharacterBufferSize)
{}
const CharT* cbegin() const BOOST_NOEXCEPT {
return start;
}
const CharT* cend() const BOOST_NOEXCEPT {
return finish;
}
private:
/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
bool shl_char(CharT ch) BOOST_NOEXCEPT {
Traits::assign(buffer[0], ch);
finish = start + 1;
return true;
}
#ifndef BOOST_LCAST_NO_WCHAR_T
template <class T>
bool shl_char(T ch) {
BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
"boost::lexical_cast does not support narrowing of char types."
"Use boost::locale instead" );
#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
std::locale loc;
CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
#else
CharT const w = static_cast<CharT>(ch);
#endif
Traits::assign(buffer[0], w);
finish = start + 1;
return true;
}
#endif
bool shl_char_array(CharT const* str_value) BOOST_NOEXCEPT {
start = str_value;
finish = start + Traits::length(str_value);
return true;
}
template <class T>
bool shl_char_array(T const* str_value) {
BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
"boost::lexical_cast does not support narrowing of char types."
"Use boost::locale instead" );
return shl_input_streamable(str_value);
}
bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT {
start = str;
finish = std::find(start, start + max_size, Traits::to_char_type(0));
return true;
}
template<typename InputStreamable>
bool shl_input_streamable(InputStreamable& input) {
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
// If you have compilation error at this point, than your STL library
// does not support such conversions. Try updating it.
BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
#endif
#ifndef BOOST_NO_EXCEPTIONS
out_stream.exceptions(std::ios::badbit);
try {
#endif
bool const result = !(out_stream << input).fail();
const deduced_out_buffer_t* const p = static_cast<deduced_out_buffer_t*>(
out_stream.rdbuf()
);
start = p->pbase();
finish = p->pptr();
return result;
#ifndef BOOST_NO_EXCEPTIONS
} catch (const ::std::ios_base::failure& /*f*/) {
return false;
}
#endif
}
template <class T>
inline bool shl_unsigned(const T n) {
CharT* tmp_finish = buffer + CharacterBufferSize;
start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert();
finish = tmp_finish;
return true;
}
template <class T>
inline bool shl_signed(const T n) {
CharT* tmp_finish = buffer + CharacterBufferSize;
typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type utype;
CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
if (n < 0) {
--tmp_start;
CharT const minus = lcast_char_constants<CharT>::minus;
Traits::assign(*tmp_start, minus);
}
start = tmp_start;
finish = tmp_finish;
return true;
}
template <class T, class SomeCharT>
bool shl_real_type(const T& val, SomeCharT* /*begin*/) {
lcast_set_precision(out_stream, &val);
return shl_input_streamable(val);
}
bool shl_real_type(float val, char* begin) {
using namespace std;
const double val_as_double = val;
finish = start +
#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
sprintf_s(begin, CharacterBufferSize,
#else
sprintf(begin,
#endif
"%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
return finish > start;
}
bool shl_real_type(double val, char* begin) {
using namespace std;
finish = start +
#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
sprintf_s(begin, CharacterBufferSize,
#else
sprintf(begin,
#endif
"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
return finish > start;
}
#ifndef __MINGW32__
bool shl_real_type(long double val, char* begin) {
using namespace std;
finish = start +
#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
sprintf_s(begin, CharacterBufferSize,
#else
sprintf(begin,
#endif
"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
return finish > start;
}
#endif
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
bool shl_real_type(float val, wchar_t* begin) {
using namespace std;
const double val_as_double = val;
finish = start + swprintf(begin, CharacterBufferSize,
L"%.*g",
static_cast<int>(boost::detail::lcast_get_precision<float >()),
val_as_double );
return finish > start;
}
bool shl_real_type(double val, wchar_t* begin) {
using namespace std;
finish = start + swprintf(begin, CharacterBufferSize,
L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
return finish > start;
}
bool shl_real_type(long double val, wchar_t* begin) {
using namespace std;
finish = start + swprintf(begin, CharacterBufferSize,
L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
return finish > start;
}
#endif
template <class T>
bool shl_real(T val) {
CharT* tmp_finish = buffer + CharacterBufferSize;
if (put_inf_nan(buffer, tmp_finish, val)) {
finish = tmp_finish;
return true;
}
return shl_real_type(val, static_cast<CharT*>(buffer));
}
/************************************ OPERATORS << ( ... ) ********************************/
public:
template<class Alloc>
bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
start = str.data();
finish = start + str.length();
return true;
}
template<class Alloc>
bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
start = str.data();
finish = start + str.length();
return true;
}
bool operator<<(bool value) BOOST_NOEXCEPT {
CharT const czero = lcast_char_constants<CharT>::zero;
Traits::assign(buffer[0], Traits::to_char_type(czero + value));
finish = start + 1;
return true;
}
template <class C>
BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type
operator<<(const iterator_range<C*>& rng) BOOST_NOEXCEPT {
return (*this) << iterator_range<const C*>(rng.begin(), rng.end());
}
bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT {
start = rng.begin();
finish = rng.end();
return true;
}
bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT {
return (*this) << iterator_range<const char*>(
reinterpret_cast<const char*>(rng.begin()),
reinterpret_cast<const char*>(rng.end())
);
}
bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT {
return (*this) << iterator_range<const char*>(
reinterpret_cast<const char*>(rng.begin()),
reinterpret_cast<const char*>(rng.end())
);
}
bool operator<<(char ch) { return shl_char(ch); }
bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); }
bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); }
#if !defined(BOOST_LCAST_NO_WCHAR_T)
bool operator<<(wchar_t const* str) { return shl_char_array(str); }
bool operator<<(wchar_t * str) { return shl_char_array(str); }
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
bool operator<<(wchar_t ch) { return shl_char(ch); }
#endif
#endif
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
bool operator<<(char16_t ch) { return shl_char(ch); }
bool operator<<(char16_t * str) { return shl_char_array(str); }
bool operator<<(char16_t const * str) { return shl_char_array(str); }
#endif
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
bool operator<<(char32_t ch) { return shl_char(ch); }
bool operator<<(char32_t * str) { return shl_char_array(str); }
bool operator<<(char32_t const * str) { return shl_char_array(str); }
#endif
bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
bool operator<<(char const* str_value) { return shl_char_array(str_value); }
bool operator<<(char* str_value) { return shl_char_array(str_value); }
bool operator<<(short n) { return shl_signed(n); }
bool operator<<(int n) { return shl_signed(n); }
bool operator<<(long n) { return shl_signed(n); }
bool operator<<(unsigned short n) { return shl_unsigned(n); }
bool operator<<(unsigned int n) { return shl_unsigned(n); }
bool operator<<(unsigned long n) { return shl_unsigned(n); }
#if defined(BOOST_HAS_LONG_LONG)
bool operator<<(boost::ulong_long_type n) { return shl_unsigned(n); }
bool operator<<(boost::long_long_type n) { return shl_signed(n); }
#elif defined(BOOST_HAS_MS_INT64)
bool operator<<(unsigned __int64 n) { return shl_unsigned(n); }
bool operator<<( __int64 n) { return shl_signed(n); }
#endif
#ifdef BOOST_HAS_INT128
bool operator<<(const boost::uint128_type& n) { return shl_unsigned(n); }
bool operator<<(const boost::int128_type& n) { return shl_signed(n); }
#endif
bool operator<<(float val) { return shl_real(val); }
bool operator<<(double val) { return shl_real(val); }
bool operator<<(long double val) {
#ifndef __MINGW32__
return shl_real(val);
#else
return shl_real(static_cast<double>(val));
#endif
}
// Adding constness to characters. Constness does not change layout
template <class C, std::size_t N>
BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type
operator<<(boost::array<C, N> const& input) BOOST_NOEXCEPT {
BOOST_STATIC_ASSERT_MSG(
(sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>)),
"boost::array<C, N> and boost::array<const C, N> must have exactly the same layout."
);
return ((*this) << reinterpret_cast<boost::array<const C, N> const& >(input));
}
template <std::size_t N>
bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT {
return shl_char_array_limited(input.data(), N);
}
template <std::size_t N>
bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT {
return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
}
template <std::size_t N>
bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT {
return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
}
#ifndef BOOST_NO_CXX11_HDR_ARRAY
// Making a Boost.Array from std::array
template <class C, std::size_t N>
bool operator<<(std::array<C, N> const& input) BOOST_NOEXCEPT {
BOOST_STATIC_ASSERT_MSG(
(sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
"std::array and boost::array must have exactly the same layout. "
"Bug in implementation of std::array or boost::array."
);
return ((*this) << reinterpret_cast<boost::array<C, N> const& >(input));
}
#endif
template <class InStreamable>
bool operator<<(const InStreamable& input) { return shl_input_streamable(input); }
};
template <class CharT, class Traits>
class lexical_ostream_limited_src: boost::noncopyable {
//`[start, finish)` is the range to output by `operator >>`
const CharT* start;
const CharT* const finish;
public:
lexical_ostream_limited_src(const CharT* begin, const CharT* end) BOOST_NOEXCEPT
: start(begin)
, finish(end)
{}
/************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/
private:
template <typename Type>
bool shr_unsigned(Type& output) {
if (start == finish) return false;
CharT const minus = lcast_char_constants<CharT>::minus;
CharT const plus = lcast_char_constants<CharT>::plus;
bool const has_minus = Traits::eq(minus, *start);
/* We won`t use `start' any more, so no need in decrementing it after */
if (has_minus || Traits::eq(plus, *start)) {
++start;
}
bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert();
if (has_minus) {
output = static_cast<Type>(0u - output);
}
return succeed;
}
template <typename Type>
bool shr_signed(Type& output) {
if (start == finish) return false;
CharT const minus = lcast_char_constants<CharT>::minus;
CharT const plus = lcast_char_constants<CharT>::plus;
typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
utype out_tmp = 0;
bool const has_minus = Traits::eq(minus, *start);
/* We won`t use `start' any more, so no need in decrementing it after */
if (has_minus || Traits::eq(plus, *start)) {
++start;
}
bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert();
if (has_minus) {
utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
succeed = succeed && out_tmp<=comp_val;
output = static_cast<Type>(0u - out_tmp);
} else {
utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
succeed = succeed && out_tmp<=comp_val;
output = static_cast<Type>(out_tmp);
}
return succeed;
}
template<typename InputStreamable>
bool shr_using_base_class(InputStreamable& output)
{
BOOST_STATIC_ASSERT_MSG(
(!boost::is_pointer<InputStreamable>::value),
"boost::lexical_cast can not convert to pointers"
);
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
BOOST_STATIC_ASSERT_MSG((boost::is_same<char, CharT>::value),
"boost::lexical_cast can not convert, because your STL library does not "
"support such conversions. Try updating it."
);
#endif
#if defined(BOOST_NO_STRINGSTREAM)
std::istrstream stream(start, static_cast<std::istrstream::streamsize>(finish - start));
#else
typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t buffer_t;
buffer_t buf;
// Usually `istream` and `basic_istream` do not modify
// content of buffer; `buffer_t` assures that this is true
buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));
#if defined(BOOST_NO_STD_LOCALE)
std::istream stream(&buf);
#else
std::basic_istream<CharT, Traits> stream(&buf);
#endif // BOOST_NO_STD_LOCALE
#endif // BOOST_NO_STRINGSTREAM
#ifndef BOOST_NO_EXCEPTIONS
stream.exceptions(std::ios::badbit);
try {
#endif
stream.unsetf(std::ios::skipws);
lcast_set_precision(stream, static_cast<InputStreamable*>(0));
return (stream >> output)
&& (stream.get() == Traits::eof());
#ifndef BOOST_NO_EXCEPTIONS
} catch (const ::std::ios_base::failure& /*f*/) {
return false;
}
#endif
}
template<class T>
inline bool shr_xchar(T& output) BOOST_NOEXCEPT {
BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
"boost::lexical_cast does not support narrowing of character types."
"Use boost::locale instead" );
bool const ok = (finish - start == 1);
if (ok) {
CharT out;
Traits::assign(out, *start);
output = static_cast<T>(out);
}
return ok;
}
template <std::size_t N, class ArrayT>
bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT {
using namespace std;
const std::size_t size = static_cast<std::size_t>(finish - start);
if (size > N - 1) { // `-1` because we need to store \0 at the end
return false;
}
memcpy(&output[0], start, size * sizeof(CharT));
output[size] = Traits::to_char_type(0);
return true;
}
/************************************ OPERATORS >> ( ... ) ********************************/
public:
bool operator>>(unsigned short& output) { return shr_unsigned(output); }
bool operator>>(unsigned int& output) { return shr_unsigned(output); }
bool operator>>(unsigned long int& output) { return shr_unsigned(output); }
bool operator>>(short& output) { return shr_signed(output); }
bool operator>>(int& output) { return shr_signed(output); }
bool operator>>(long int& output) { return shr_signed(output); }
#if defined(BOOST_HAS_LONG_LONG)
bool operator>>(boost::ulong_long_type& output) { return shr_unsigned(output); }
bool operator>>(boost::long_long_type& output) { return shr_signed(output); }
#elif defined(BOOST_HAS_MS_INT64)
bool operator>>(unsigned __int64& output) { return shr_unsigned(output); }
bool operator>>(__int64& output) { return shr_signed(output); }
#endif
#ifdef BOOST_HAS_INT128
bool operator>>(boost::uint128_type& output) { return shr_unsigned(output); }
bool operator>>(boost::int128_type& output) { return shr_signed(output); }
#endif
bool operator>>(char& output) { return shr_xchar(output); }
bool operator>>(unsigned char& output) { return shr_xchar(output); }
bool operator>>(signed char& output) { return shr_xchar(output); }
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
bool operator>>(wchar_t& output) { return shr_xchar(output); }
#endif
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
bool operator>>(char16_t& output) { return shr_xchar(output); }
#endif
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
bool operator>>(char32_t& output) { return shr_xchar(output); }
#endif
template<class Alloc>
bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) {
str.assign(start, finish); return true;
}
template<class Alloc>
bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) {
str.assign(start, finish); return true;
}
template <std::size_t N>
bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT {
return shr_std_array<N>(output);
}
template <std::size_t N>
bool operator>>(boost::array<unsigned char, N>& output) BOOST_NOEXCEPT {
return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
}
template <std::size_t N>
bool operator>>(boost::array<signed char, N>& output) BOOST_NOEXCEPT {
return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
}
#ifndef BOOST_NO_CXX11_HDR_ARRAY
template <class C, std::size_t N>
bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT {
BOOST_STATIC_ASSERT_MSG(
(sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
"std::array<C, N> and boost::array<C, N> must have exactly the same layout."
);
return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output));
}
#endif
bool operator>>(bool& output) BOOST_NOEXCEPT {
output = false; // Suppress warning about uninitalized variable
if (start == finish) return false;
CharT const zero = lcast_char_constants<CharT>::zero;
CharT const plus = lcast_char_constants<CharT>::plus;
CharT const minus = lcast_char_constants<CharT>::minus;
const CharT* const dec_finish = finish - 1;
output = Traits::eq(*dec_finish, zero + 1);
if (!output && !Traits::eq(*dec_finish, zero)) {
return false; // Does not ends on '0' or '1'
}
if (start == dec_finish) return true;
// We may have sign at the beginning
if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) {
++ start;
}
// Skipping zeros
while (start != dec_finish) {
if (!Traits::eq(zero, *start)) {
return false; // Not a zero => error
}
++ start;
}
return true;
}
private:
// Not optimised converter
template <class T>
bool float_types_converter_internal(T& output) {
if (parse_inf_nan(start, finish, output)) return true;
bool const return_value = shr_using_base_class(output);
/* Some compilers and libraries successfully
* parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
* We are trying to provide a unified behaviour,
* so we just forbid such conversions (as some
* of the most popular compilers/libraries do)
* */
CharT const minus = lcast_char_constants<CharT>::minus;
CharT const plus = lcast_char_constants<CharT>::plus;
CharT const capital_e = lcast_char_constants<CharT>::capital_e;
CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
if ( return_value &&
(
Traits::eq(*(finish-1), lowercase_e) // 1.0e
|| Traits::eq(*(finish-1), capital_e) // 1.0E
|| Traits::eq(*(finish-1), minus) // 1.0e- or 1.0E-
|| Traits::eq(*(finish-1), plus) // 1.0e+ or 1.0E+
)
) return false;
return return_value;
}
public:
bool operator>>(float& output) { return float_types_converter_internal(output); }
bool operator>>(double& output) { return float_types_converter_internal(output); }
bool operator>>(long double& output) { return float_types_converter_internal(output); }
// Generic istream-based algorithm.
// lcast_streambuf_for_target<InputStreamable>::value is true.
template <typename InputStreamable>
bool operator>>(InputStreamable& output) {
return shr_using_base_class(output);
}
};
}
} // namespace boost
#undef BOOST_LCAST_NO_WCHAR_T
#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP

172
3rdparty/boost/boost/lexical_cast/detail/converter_numeric.hpp vendored
View File

@ -1,172 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2016
#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#include <boost/limits.hpp>
#include <boost/type_traits/type_identity.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_float.hpp>
#include <boost/numeric/conversion/cast.hpp>
namespace boost { namespace detail {
template <class Source >
struct detect_precision_loss
{
typedef Source source_type;
typedef boost::numeric::Trunc<Source> Rounder;
typedef BOOST_DEDUCED_TYPENAME conditional<
boost::is_arithmetic<Source>::value, Source, Source const&
>::type argument_type ;
static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT {
const source_type near_int = Rounder::nearbyint(s);
if (near_int && is_ok) {
const source_type orig_div_round = s / near_int;
const source_type eps = std::numeric_limits<source_type>::epsilon();
is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps);
}
return s;
}
typedef typename Rounder::round_style round_style;
};
template <typename Base, class Source>
struct fake_precision_loss: public Base
{
typedef Source source_type ;
typedef BOOST_DEDUCED_TYPENAME conditional<
boost::is_arithmetic<Source>::value, Source, Source const&
>::type argument_type ;
static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT {
return s;
}
};
struct nothrow_overflow_handler
{
inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT {
return (r == boost::numeric::cInRange);
}
};
template <typename Target, typename Source>
inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT {
typedef boost::numeric::converter<
Target,
Source,
boost::numeric::conversion_traits<Target, Source >,
nothrow_overflow_handler,
detect_precision_loss<Source >
> converter_orig_t;
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value,
converter_orig_t,
fake_precision_loss<converter_orig_t, Source>
>::type converter_t;
bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg));
result = converter_t::low_level_convert(converter_t::nearbyint(arg, res));
return res;
}
template <typename Target, typename Source>
struct lexical_cast_dynamic_num_not_ignoring_minus
{
static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
return noexcept_numeric_convert<Target, Source >(arg, result);
}
};
template <typename Target, typename Source>
struct lexical_cast_dynamic_num_ignoring_minus
{
static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::is_float<Source>::value,
boost::type_identity<Source>,
boost::make_unsigned<Source>
>::type usource_lazy_t;
typedef BOOST_DEDUCED_TYPENAME usource_lazy_t::type usource_t;
if (arg < 0) {
const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result);
result = static_cast<Target>(0u - result);
return res;
} else {
return noexcept_numeric_convert<Target, usource_t>(arg, result);
}
}
};
/*
* lexical_cast_dynamic_num follows the rules:
* 1) If Source can be converted to Target without precision loss and
* without overflows, then assign Source to Target and return
*
* 2) If Source is less than 0 and Target is an unsigned integer,
* then negate Source, check the requirements of rule 1) and if
* successful, assign static_casted Source to Target and return
*
* 3) Otherwise throw a bad_lexical_cast exception
*
*
* Rule 2) required because boost::lexical_cast has the behavior of
* stringstream, which uses the rules of scanf for conversions. And
* in the C99 standard for unsigned input value minus sign is
* optional, so if a negative number is read, no errors will arise
* and the result will be the two's complement.
*/
template <typename Target, typename Source>
struct dynamic_num_converter_impl
{
static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
boost::is_unsigned<Target>::value &&
(boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
!(boost::is_same<Source, bool>::value) &&
!(boost::is_same<Target, bool>::value),
lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
>::type caster_type;
return caster_type::try_convert(arg, result);
}
};
}} // namespace boost::detail
#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP

197
3rdparty/boost/boost/lexical_cast/detail/inf_nan.hpp vendored
View File

@ -1,197 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
#define BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
#define BOOST_LCAST_NO_WCHAR_T
#endif
#include <cstddef>
#include <cstring>
#include <boost/limits.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/math/special_functions/sign.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
namespace boost {
namespace detail
{
template <class CharT>
bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
for( unsigned int i=0; i < len; ++i ) {
if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
}
return true;
}
/* Returns true and sets the correct value if found NaN or Inf. */
template <class CharT, class T>
inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
, const CharT* lc_NAN, const CharT* lc_nan
, const CharT* lc_INFINITY, const CharT* lc_infinity
, const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
{
using namespace std;
if (begin == end) return false;
const CharT minus = lcast_char_constants<CharT>::minus;
const CharT plus = lcast_char_constants<CharT>::plus;
const int inifinity_size = 8; // == sizeof("infinity") - 1
/* Parsing +/- */
bool const has_minus = (*begin == minus);
if (has_minus || *begin == plus) {
++ begin;
}
if (end - begin < 3) return false;
if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
begin += 3;
if (end != begin) {
/* It is 'nan(...)' or some bad input*/
if (end - begin < 2) return false; // bad input
-- end;
if (*begin != opening_brace || *end != closing_brace) return false; // bad input
}
if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
return true;
} else if (
( /* 'INF' or 'inf' */
end - begin == 3 // 3 == sizeof('inf') - 1
&& lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
)
||
( /* 'INFINITY' or 'infinity' */
end - begin == inifinity_size
&& lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
)
)
{
if( !has_minus ) value = std::numeric_limits<T>::infinity();
else value = (boost::math::changesign) (std::numeric_limits<T>::infinity());
return true;
}
return false;
}
template <class CharT, class T>
bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
, const CharT* lc_nan
, const CharT* lc_infinity) BOOST_NOEXCEPT
{
using namespace std;
const CharT minus = lcast_char_constants<CharT>::minus;
if ((boost::math::isnan)(value)) {
if ((boost::math::signbit)(value)) {
*begin = minus;
++ begin;
}
memcpy(begin, lc_nan, 3 * sizeof(CharT));
end = begin + 3;
return true;
} else if ((boost::math::isinf)(value)) {
if ((boost::math::signbit)(value)) {
*begin = minus;
++ begin;
}
memcpy(begin, lc_infinity, 3 * sizeof(CharT));
end = begin + 3;
return true;
}
return false;
}
#ifndef BOOST_LCAST_NO_WCHAR_T
template <class T>
bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT {
return parse_inf_nan_impl(begin, end, value
, L"NAN", L"nan"
, L"INFINITY", L"infinity"
, L'(', L')');
}
template <class T>
bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT {
return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
}
#endif
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
template <class T>
bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT {
return parse_inf_nan_impl(begin, end, value
, u"NAN", u"nan"
, u"INFINITY", u"infinity"
, u'(', u')');
}
template <class T>
bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT {
return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
}
#endif
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
template <class T>
bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT {
return parse_inf_nan_impl(begin, end, value
, U"NAN", U"nan"
, U"INFINITY", U"infinity"
, U'(', U')');
}
template <class T>
bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT {
return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
}
#endif
template <class CharT, class T>
bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT {
return parse_inf_nan_impl(begin, end, value
, "NAN", "nan"
, "INFINITY", "infinity"
, '(', ')');
}
template <class CharT, class T>
bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT {
return put_inf_nan_impl(begin, end, value, "nan", "infinity");
}
}
} // namespace boost
#undef BOOST_LCAST_NO_WCHAR_T
#endif // BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP

59
3rdparty/boost/boost/lexical_cast/detail/is_character.hpp vendored
View File

@ -1,59 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
#define BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost {
namespace detail // is_character<...>
{
// returns true, if T is one of the character types
template < typename T >
struct is_character
{
typedef BOOST_DEDUCED_TYPENAME boost::integral_constant<
bool,
boost::is_same< T, char >::value ||
#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
boost::is_same< T, wchar_t >::value ||
#endif
#ifndef BOOST_NO_CXX11_CHAR16_T
boost::is_same< T, char16_t >::value ||
#endif
#ifndef BOOST_NO_CXX11_CHAR32_T
boost::is_same< T, char32_t >::value ||
#endif
boost::is_same< T, unsigned char >::value ||
boost::is_same< T, signed char >::value
> type;
BOOST_STATIC_CONSTANT(bool, value = (type::value) );
};
}
}
#endif // BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP

46
3rdparty/boost/boost/lexical_cast/detail/lcast_char_constants.hpp vendored
View File

@ -1,46 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
#define BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
namespace boost
{
namespace detail // '0', '-', '+', 'e', 'E' and '.' constants
{
template < typename Char >
struct lcast_char_constants {
// We check in tests assumption that static casted character is
// equal to correctly written C++ literal: U'0' == static_cast<char32_t>('0')
BOOST_STATIC_CONSTANT(Char, zero = static_cast<Char>('0'));
BOOST_STATIC_CONSTANT(Char, minus = static_cast<Char>('-'));
BOOST_STATIC_CONSTANT(Char, plus = static_cast<Char>('+'));
BOOST_STATIC_CONSTANT(Char, lowercase_e = static_cast<Char>('e'));
BOOST_STATIC_CONSTANT(Char, capital_e = static_cast<Char>('E'));
BOOST_STATIC_CONSTANT(Char, c_decimal_separator = static_cast<Char>('.'));
};
}
} // namespace boost
#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP

294
3rdparty/boost/boost/lexical_cast/detail/lcast_unsigned_converters.hpp vendored
View File

@ -1,294 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
#define BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#include <climits>
#include <cstddef>
#include <string>
#include <cstring>
#include <cstdio>
#include <boost/limits.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>
#ifndef BOOST_NO_STD_LOCALE
# include <locale>
#else
# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
// Getting error at this point means, that your STL library is old/lame/misconfigured.
// If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
// but beware: lexical_cast will understand only 'C' locale delimeters and thousands
// separators.
# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
# error "boost::lexical_cast to use only 'C' locale during conversions."
# endif
#endif
#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/noncopyable.hpp>
namespace boost
{
namespace detail // lcast_to_unsigned
{
template<class T>
inline
BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT {
typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type;
return value < 0
? static_cast<result_type>(0u - static_cast<result_type>(value))
: static_cast<result_type>(value);
}
}
namespace detail // lcast_put_unsigned
{
template <class Traits, class T, class CharT>
class lcast_put_unsigned: boost::noncopyable {
typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type;
BOOST_DEDUCED_TYPENAME boost::conditional<
(sizeof(unsigned) > sizeof(T))
, unsigned
, T
>::type m_value;
CharT* m_finish;
CharT const m_czero;
int_type const m_zero;
public:
lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT
: m_value(n_param), m_finish(finish)
, m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
{
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
#endif
}
CharT* convert() {
#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
std::locale loc;
if (loc == std::locale::classic()) {
return main_convert_loop();
}
typedef std::numpunct<CharT> numpunct;
numpunct const& np = BOOST_USE_FACET(numpunct, loc);
std::string const grouping = np.grouping();
std::string::size_type const grouping_size = grouping.size();
if (!grouping_size || grouping[0] <= 0) {
return main_convert_loop();
}
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
// Check that ulimited group is unreachable:
BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
#endif
CharT const thousands_sep = np.thousands_sep();
std::string::size_type group = 0; // current group number
char last_grp_size = grouping[0];
char left = last_grp_size;
do {
if (left == 0) {
++group;
if (group < grouping_size) {
char const grp_size = grouping[group];
last_grp_size = (grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size);
}
left = last_grp_size;
--m_finish;
Traits::assign(*m_finish, thousands_sep);
}
--left;
} while (main_convert_iteration());
return m_finish;
#else
return main_convert_loop();
#endif
}
private:
inline bool main_convert_iteration() BOOST_NOEXCEPT {
--m_finish;
int_type const digit = static_cast<int_type>(m_value % 10U);
Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
m_value /= 10;
return !!m_value; // suppressing warnings
}
inline CharT* main_convert_loop() BOOST_NOEXCEPT {
while (main_convert_iteration());
return m_finish;
}
};
}
namespace detail // lcast_ret_unsigned
{
template <class Traits, class T, class CharT>
class lcast_ret_unsigned: boost::noncopyable {
bool m_multiplier_overflowed;
T m_multiplier;
T& m_value;
const CharT* const m_begin;
const CharT* m_end;
public:
lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT
: m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
{
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
// GCC when used with flag -std=c++0x may not have std::numeric_limits
// specializations for __int128 and unsigned __int128 types.
// Try compilation with -std=gnu++0x or -std=gnu++11.
//
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized,
"std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
);
#endif
}
inline bool convert() {
CharT const czero = lcast_char_constants<CharT>::zero;
--m_end;
m_value = static_cast<T>(0);
if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10)
return false;
m_value = static_cast<T>(*m_end - czero);
--m_end;
#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
return main_convert_loop();
#else
std::locale loc;
if (loc == std::locale::classic()) {
return main_convert_loop();
}
typedef std::numpunct<CharT> numpunct;
numpunct const& np = BOOST_USE_FACET(numpunct, loc);
std::string const& grouping = np.grouping();
std::string::size_type const grouping_size = grouping.size();
/* According to Programming languages - C++
* we MUST check for correct grouping
*/
if (!grouping_size || grouping[0] <= 0) {
return main_convert_loop();
}
unsigned char current_grouping = 0;
CharT const thousands_sep = np.thousands_sep();
char remained = static_cast<char>(grouping[current_grouping] - 1);
for (;m_end >= m_begin; --m_end)
{
if (remained) {
if (!main_convert_iteration()) {
return false;
}
--remained;
} else {
if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false;
{
/*
* According to Programming languages - C++
* Digit grouping is checked. That is, the positions of discarded
* separators is examined for consistency with
* use_facet<numpunct<charT> >(loc ).grouping()
*
* BUT what if there is no separators at all and grouping()
* is not empty? Well, we have no extraced separators, so we
* won`t check them for consistency. This will allow us to
* work with "C" locale from other locales
*/
return main_convert_loop();
} else {
if (m_begin == m_end) return false;
if (current_grouping < grouping_size - 1) ++current_grouping;
remained = grouping[current_grouping];
}
}
} /*for*/
return true;
#endif
}
private:
// Iteration that does not care about grouping/separators and assumes that all
// input characters are digits
inline bool main_convert_iteration() BOOST_NOEXCEPT {
CharT const czero = lcast_char_constants<CharT>::zero;
T const maxv = (std::numeric_limits<T>::max)();
m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier);
m_multiplier = static_cast<T>(m_multiplier * 10);
T const dig_value = static_cast<T>(*m_end - czero);
T const new_sub_value = static_cast<T>(m_multiplier * dig_value);
// We must correctly handle situations like `000000000000000000000000000001`.
// So we take care of overflow only if `dig_value` is not '0'.
if (*m_end < czero || *m_end >= czero + 10 // checking for correct digit
|| (dig_value && ( // checking for overflow of ...
m_multiplier_overflowed // ... multiplier
|| static_cast<T>(maxv / dig_value) < m_multiplier // ... subvalue
|| static_cast<T>(maxv - new_sub_value) < m_value // ... whole expression
))
) return false;
m_value = static_cast<T>(m_value + new_sub_value);
return true;
}
bool main_convert_loop() BOOST_NOEXCEPT {
for ( ; m_end >= m_begin; --m_end) {
if (!main_convert_iteration()) {
return false;
}
}
return true;
}
};
}
} // namespace boost
#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP

43
3rdparty/boost/boost/lexical_cast/detail/widest_char.hpp vendored
View File

@ -1,43 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
#define BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#include <boost/type_traits/conditional.hpp>
namespace boost { namespace detail {
template <typename TargetChar, typename SourceChar>
struct widest_char {
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
(sizeof(TargetChar) > sizeof(SourceChar))
, TargetChar
, SourceChar
>::type type;
};
}} // namespace boost::detail
#endif // BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP

232
3rdparty/boost/boost/lexical_cast/try_lexical_convert.hpp vendored
View File

@ -1,232 +0,0 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2019.
//
// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
#define BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
#if defined(__clang__) || (defined(__GNUC__) && \
!(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && \
(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
#include <string>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/type_identity.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/lexical_cast/detail/is_character.hpp>
#include <boost/lexical_cast/detail/converter_numeric.hpp>
#include <boost/lexical_cast/detail/converter_lexical.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/container/container_fwd.hpp>
namespace boost {
namespace detail
{
template<typename T>
struct is_stdstring
: boost::false_type
{};
template<typename CharT, typename Traits, typename Alloc>
struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
: boost::true_type
{};
// Sun Studio has problem with partial specialization of templates differing only in namespace.
// We workaround that by making `is_booststring` trait, instead of specializing `is_stdstring` for `boost::container::basic_string`.
template<typename T>
struct is_booststring
: boost::false_type
{};
template<typename CharT, typename Traits, typename Alloc>
struct is_booststring< boost::container::basic_string<CharT, Traits, Alloc> >
: boost::true_type
{};
template<typename Target, typename Source>
struct is_arithmetic_and_not_xchars
{
typedef boost::integral_constant<
bool,
!(boost::detail::is_character<Target>::value) &&
!(boost::detail::is_character<Source>::value) &&
boost::is_arithmetic<Source>::value &&
boost::is_arithmetic<Target>::value
> type;
BOOST_STATIC_CONSTANT(bool, value = (
type::value
));
};
/*
* is_xchar_to_xchar<Target, Source>::value is true,
* Target and Souce are char types of the same size 1 (char, signed char, unsigned char).
*/
template<typename Target, typename Source>
struct is_xchar_to_xchar
{
typedef boost::integral_constant<
bool,
sizeof(Source) == sizeof(Target) &&
sizeof(Source) == sizeof(char) &&
boost::detail::is_character<Target>::value &&
boost::detail::is_character<Source>::value
> type;
BOOST_STATIC_CONSTANT(bool, value = (
type::value
));
};
template<typename Target, typename Source>
struct is_char_array_to_stdstring
: boost::false_type
{};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
: boost::true_type
{};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
: boost::true_type
{};
// Sun Studio has problem with partial specialization of templates differing only in namespace.
// We workaround that by making `is_char_array_to_booststring` trait, instead of specializing `is_char_array_to_stdstring` for `boost::container::basic_string`.
template<typename Target, typename Source>
struct is_char_array_to_booststring
: boost::false_type
{};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
: boost::true_type
{};
template<typename CharT, typename Traits, typename Alloc>
struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
: boost::true_type
{};
template <typename Target, typename Source>
struct copy_converter_impl
{
// MSVC fail to forward an array (DevDiv#555157 "SILENT BAD CODEGEN triggered by perfect forwarding",
// fixed in 2013 RTM).
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined(BOOST_MSVC) || BOOST_MSVC >= 1800)
template <class T>
static inline bool try_convert(T&& arg, Target& result) {
result = static_cast<T&&>(arg); // eqaul to `result = std::forward<T>(arg);`
return true;
}
#else
static inline bool try_convert(const Source& arg, Target& result) {
result = arg;
return true;
}
#endif
};
}
namespace conversion { namespace detail {
template <typename Target, typename Source>
inline bool try_lexical_convert(const Source& arg, Target& result)
{
typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
typedef boost::integral_constant<
bool,
boost::detail::is_xchar_to_xchar<Target, src >::value ||
boost::detail::is_char_array_to_stdstring<Target, src >::value ||
boost::detail::is_char_array_to_booststring<Target, src >::value ||
(
boost::is_same<Target, src >::value &&
(boost::detail::is_stdstring<Target >::value || boost::detail::is_booststring<Target >::value)
) ||
(
boost::is_same<Target, src >::value &&
boost::detail::is_character<Target >::value
)
> shall_we_copy_t;
typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
shall_we_copy_with_dynamic_check_t;
// We do evaluate second `if_` lazily to avoid unnecessary instantiations
// of `shall_we_copy_with_dynamic_check_t` and improve compilation times.
typedef BOOST_DEDUCED_TYPENAME boost::conditional<
shall_we_copy_t::value,
boost::type_identity<boost::detail::copy_converter_impl<Target, src > >,
boost::conditional<
shall_we_copy_with_dynamic_check_t::value,
boost::detail::dynamic_num_converter_impl<Target, src >,
boost::detail::lexical_converter_impl<Target, src >
>
>::type caster_type_lazy;
typedef BOOST_DEDUCED_TYPENAME caster_type_lazy::type caster_type;
return caster_type::try_convert(arg, result);
}
template <typename Target, typename CharacterT>
inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
{
BOOST_STATIC_ASSERT_MSG(
boost::detail::is_character<CharacterT>::value,
"This overload of try_lexical_convert is meant to be used only with arrays of characters."
);
return ::boost::conversion::detail::try_lexical_convert(
::boost::iterator_range<const CharacterT*>(chars, chars + count), result
);
}
}} // namespace conversion::detail
namespace conversion {
// ADL barrier
using ::boost::conversion::detail::try_lexical_convert;
}
} // namespace boost
#if defined(__clang__) || (defined(__GNUC__) && \
!(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && \
(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
#pragma GCC diagnostic pop
#endif
#endif // BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP

1040
3rdparty/boost/boost/math/policies/policy.hpp vendored
View File

File diff suppressed because it is too large Load Diff

581
3rdparty/boost/boost/math/special_functions/detail/fp_traits.hpp vendored
View File

@ -1,581 +0,0 @@
// fp_traits.hpp
#ifndef BOOST_MATH_FP_TRAITS_HPP
#define BOOST_MATH_FP_TRAITS_HPP
// Copyright (c) 2006 Johan Rade
// 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)
/*
To support old compilers, care has been taken to avoid partial template
specialization and meta function forwarding.
With these techniques, the code could be simplified.
*/
#if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
// The VAX floating point formats are used (for float and double)
# define BOOST_FPCLASSIFY_VAX_FORMAT
#endif
#include <cstring>
#include <boost/assert.hpp>
#include <boost/cstdint.hpp>
#include <boost/predef/other/endian.h>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#ifdef BOOST_NO_STDC_NAMESPACE
namespace std{ using ::memcpy; }
#endif
#ifndef FP_NORMAL
#define FP_ZERO 0
#define FP_NORMAL 1
#define FP_INFINITE 2
#define FP_NAN 3
#define FP_SUBNORMAL 4
#else
#define BOOST_HAS_FPCLASSIFY
#ifndef fpclassify
# if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) \
&& defined(_GLIBCXX_USE_C99_MATH) \
&& !(defined(_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) \
&& (_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC != 0))
# ifdef _STLP_VENDOR_CSTD
# if _STLPORT_VERSION >= 0x520
# define BOOST_FPCLASSIFY_PREFIX ::__std_alias::
# else
# define BOOST_FPCLASSIFY_PREFIX ::_STLP_VENDOR_CSTD::
# endif
# else
# define BOOST_FPCLASSIFY_PREFIX ::std::
# endif
# else
# undef BOOST_HAS_FPCLASSIFY
# define BOOST_FPCLASSIFY_PREFIX
# endif
#elif (defined(__HP_aCC) && !defined(__hppa))
// aCC 6 appears to do "#define fpclassify fpclassify" which messes us up a bit!
# define BOOST_FPCLASSIFY_PREFIX ::
#else
# define BOOST_FPCLASSIFY_PREFIX
#endif
#ifdef __MINGW32__
# undef BOOST_HAS_FPCLASSIFY
#endif
#endif
//------------------------------------------------------------------------------
namespace boost {
namespace math {
namespace detail {
//------------------------------------------------------------------------------
/*
The following classes are used to tag the different methods that are used
for floating point classification
*/
struct native_tag {};
template <bool has_limits>
struct generic_tag {};
struct ieee_tag {};
struct ieee_copy_all_bits_tag : public ieee_tag {};
struct ieee_copy_leading_bits_tag : public ieee_tag {};
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
//
// These helper functions are used only when numeric_limits<>
// members are not compile time constants:
//
inline bool is_generic_tag_false(const generic_tag<false>*)
{
return true;
}
inline bool is_generic_tag_false(const void*)
{
return false;
}
#endif
//------------------------------------------------------------------------------
/*
Most processors support three different floating point precisions:
single precision (32 bits), double precision (64 bits)
and extended double precision (80 - 128 bits, depending on the processor)
Note that the C++ type long double can be implemented
both as double precision and extended double precision.
*/
struct unknown_precision{};
struct single_precision {};
struct double_precision {};
struct extended_double_precision {};
// native_tag version --------------------------------------------------------------
template<class T> struct fp_traits_native
{
typedef native_tag method;
};
// generic_tag version -------------------------------------------------------------
template<class T, class U> struct fp_traits_non_native
{
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
typedef generic_tag<std::numeric_limits<T>::is_specialized> method;
#else
typedef generic_tag<false> method;
#endif
};
// ieee_tag versions ---------------------------------------------------------------
/*
These specializations of fp_traits_non_native contain information needed
to "parse" the binary representation of a floating point number.
Typedef members:
bits -- the target type when copying the leading bytes of a floating
point number. It is a typedef for uint32_t or uint64_t.
method -- tells us whether all bytes are copied or not.
It is a typedef for ieee_copy_all_bits_tag or ieee_copy_leading_bits_tag.
Static data members:
sign, exponent, flag, significand -- bit masks that give the meaning of the
bits in the leading bytes.
Static function members:
get_bits(), set_bits() -- provide access to the leading bytes.
*/
// ieee_tag version, float (32 bits) -----------------------------------------------
#ifndef BOOST_FPCLASSIFY_VAX_FORMAT
template<> struct fp_traits_non_native<float, single_precision>
{
typedef ieee_copy_all_bits_tag method;
BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u);
BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7f800000);
BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
BOOST_STATIC_CONSTANT(uint32_t, significand = 0x007fffff);
typedef uint32_t bits;
static void get_bits(float x, uint32_t& a) { std::memcpy(&a, &x, 4); }
static void set_bits(float& x, uint32_t a) { std::memcpy(&x, &a, 4); }
};
// ieee_tag version, double (64 bits) ----------------------------------------------
#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) \
|| defined(__BORLANDC__) || defined(__CODEGEAR__)
template<> struct fp_traits_non_native<double, double_precision>
{
typedef ieee_copy_leading_bits_tag method;
BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u);
BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
BOOST_STATIC_CONSTANT(uint32_t, flag = 0);
BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
typedef uint32_t bits;
static void get_bits(double x, uint32_t& a)
{
std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
}
static void set_bits(double& x, uint32_t a)
{
std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
}
private:
#if BOOST_ENDIAN_BIG_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif BOOST_ENDIAN_LITTLE_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 4);
#else
BOOST_STATIC_ASSERT(false);
#endif
};
//..............................................................................
#else
template<> struct fp_traits_non_native<double, double_precision>
{
typedef ieee_copy_all_bits_tag method;
static const uint64_t sign = ((uint64_t)0x80000000u) << 32;
static const uint64_t exponent = ((uint64_t)0x7ff00000) << 32;
static const uint64_t flag = 0;
static const uint64_t significand
= (((uint64_t)0x000fffff) << 32) + ((uint64_t)0xffffffffu);
typedef uint64_t bits;
static void get_bits(double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
static void set_bits(double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
};
#endif
#endif // #ifndef BOOST_FPCLASSIFY_VAX_FORMAT
// long double (64 bits) -------------------------------------------------------
#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)\
|| defined(__BORLANDC__) || defined(__CODEGEAR__)
template<> struct fp_traits_non_native<long double, double_precision>
{
typedef ieee_copy_leading_bits_tag method;
BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u);
BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
BOOST_STATIC_CONSTANT(uint32_t, flag = 0);
BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
typedef uint32_t bits;
static void get_bits(long double x, uint32_t& a)
{
std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
}
static void set_bits(long double& x, uint32_t a)
{
std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
}
private:
#if BOOST_ENDIAN_BIG_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif BOOST_ENDIAN_LITTLE_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 4);
#else
BOOST_STATIC_ASSERT(false);
#endif
};
//..............................................................................
#else
template<> struct fp_traits_non_native<long double, double_precision>
{
typedef ieee_copy_all_bits_tag method;
static const uint64_t sign = (uint64_t)0x80000000u << 32;
static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
static const uint64_t flag = 0;
static const uint64_t significand
= ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffffu;
typedef uint64_t bits;
static void get_bits(long double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
static void set_bits(long double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
};
#endif
// long double (>64 bits), x86 and x64 -----------------------------------------
#if defined(__i386) || defined(__i386__) || defined(_M_IX86) \
|| defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) \
|| defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)
// Intel extended double precision format (80 bits)
template<>
struct fp_traits_non_native<long double, extended_double_precision>
{
typedef ieee_copy_leading_bits_tag method;
BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u);
BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000);
BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff);
typedef uint32_t bits;
static void get_bits(long double x, uint32_t& a)
{
std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
}
static void set_bits(long double& x, uint32_t a)
{
std::memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
}
};
// long double (>64 bits), Itanium ---------------------------------------------
#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
// The floating point format is unknown at compile time
// No template specialization is provided.
// The generic_tag definition is used.
// The Itanium supports both
// the Intel extended double precision format (80 bits) and
// the IEEE extended double precision format with 15 exponent bits (128 bits).
#elif defined(__GNUC__) && (LDBL_MANT_DIG == 106)
//
// Define nothing here and fall though to generic_tag:
// We have GCC's "double double" in effect, and any attempt
// to handle it via bit-fiddling is pretty much doomed to fail...
//
// long double (>64 bits), PowerPC ---------------------------------------------
#elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \
|| defined(__ppc) || defined(__ppc__) || defined(__PPC__)
// PowerPC extended double precision format (128 bits)
template<>
struct fp_traits_non_native<long double, extended_double_precision>
{
typedef ieee_copy_leading_bits_tag method;
BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u);
BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
typedef uint32_t bits;
static void get_bits(long double x, uint32_t& a)
{
std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
}
static void set_bits(long double& x, uint32_t a)
{
std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
}
private:
#if BOOST_ENDIAN_BIG_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif BOOST_ENDIAN_LITTLE_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 12);
#else
BOOST_STATIC_ASSERT(false);
#endif
};
// long double (>64 bits), Motorola 68K ----------------------------------------
#elif defined(__m68k) || defined(__m68k__) \
|| defined(__mc68000) || defined(__mc68000__) \
// Motorola extended double precision format (96 bits)
// It is the same format as the Intel extended double precision format,
// except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and
// 3) the flag bit is not set for infinity
template<>
struct fp_traits_non_native<long double, extended_double_precision>
{
typedef ieee_copy_leading_bits_tag method;
BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u);
BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000);
BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff);
// copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding.
typedef uint32_t bits;
static void get_bits(long double x, uint32_t& a)
{
std::memcpy(&a, &x, 2);
std::memcpy(reinterpret_cast<unsigned char*>(&a) + 2,
reinterpret_cast<const unsigned char*>(&x) + 4, 2);
}
static void set_bits(long double& x, uint32_t a)
{
std::memcpy(&x, &a, 2);
std::memcpy(reinterpret_cast<unsigned char*>(&x) + 4,
reinterpret_cast<const unsigned char*>(&a) + 2, 2);
}
};
// long double (>64 bits), All other processors --------------------------------
#else
// IEEE extended double precision format with 15 exponent bits (128 bits)
template<>
struct fp_traits_non_native<long double, extended_double_precision>
{
typedef ieee_copy_leading_bits_tag method;
BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000u);
BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
BOOST_STATIC_CONSTANT(uint32_t, significand = 0x0000ffff);
typedef uint32_t bits;
static void get_bits(long double x, uint32_t& a)
{
std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
}
static void set_bits(long double& x, uint32_t a)
{
std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
}
private:
#if BOOST_ENDIAN_BIG_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif BOOST_ENDIAN_LITTLE_BYTE
BOOST_STATIC_CONSTANT(int, offset_ = 12);
#else
BOOST_STATIC_ASSERT(false);
#endif
};
#endif
//------------------------------------------------------------------------------
// size_to_precision is a type switch for converting a C++ floating point type
// to the corresponding precision type.
template<int n, bool fp> struct size_to_precision
{
typedef unknown_precision type;
};
template<> struct size_to_precision<4, true>
{
typedef single_precision type;
};
template<> struct size_to_precision<8, true>
{
typedef double_precision type;
};
template<> struct size_to_precision<10, true>
{
typedef extended_double_precision type;
};
template<> struct size_to_precision<12, true>
{
typedef extended_double_precision type;
};
template<> struct size_to_precision<16, true>
{
typedef extended_double_precision type;
};
//------------------------------------------------------------------------------
//
// Figure out whether to use native classification functions based on
// whether T is a built in floating point type or not:
//
template <class T>
struct select_native
{
typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
typedef fp_traits_non_native<T, precision> type;
};
template<>
struct select_native<float>
{
typedef fp_traits_native<float> type;
};
template<>
struct select_native<double>
{
typedef fp_traits_native<double> type;
};
template<>
struct select_native<long double>
{
typedef fp_traits_native<long double> type;
};
//------------------------------------------------------------------------------
// fp_traits is a type switch that selects the right fp_traits_non_native
#if (defined(BOOST_MATH_USE_C99) && !(defined(__GNUC__) && (__GNUC__ < 4))) \
&& !defined(__hpux) \
&& !defined(__DECCXX)\
&& !defined(__osf__) \
&& !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)\
&& !defined(__FAST_MATH__)\
&& !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)\
&& !defined(BOOST_INTEL)\
&& !defined(sun)\
&& !defined(__VXWORKS__)
# define BOOST_MATH_USE_STD_FPCLASSIFY
#endif
template<class T> struct fp_traits
{
typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)
typedef typename select_native<T>::type type;
#else
typedef fp_traits_non_native<T, precision> type;
#endif
typedef fp_traits_non_native<T, precision> sign_change_type;
};
//------------------------------------------------------------------------------
} // namespace detail
} // namespace math
} // namespace boost
#endif

93
3rdparty/boost/boost/math/special_functions/detail/round_fwd.hpp vendored
View File

@ -1,93 +0,0 @@
// Copyright John Maddock 2008.
// Use, modification and distribution are 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)
#ifndef BOOST_MATH_SPECIAL_ROUND_FWD_HPP
#define BOOST_MATH_SPECIAL_ROUND_FWD_HPP
#include <boost/config.hpp>
#include <boost/math/tools/promotion.hpp>
#ifdef _MSC_VER
#pragma once
#endif
namespace boost
{
namespace math
{
template <class T, class Policy>
typename tools::promote_args<T>::type trunc(const T& v, const Policy& pol);
template <class T>
typename tools::promote_args<T>::type trunc(const T& v);
template <class T, class Policy>
int itrunc(const T& v, const Policy& pol);
template <class T>
int itrunc(const T& v);
template <class T, class Policy>
long ltrunc(const T& v, const Policy& pol);
template <class T>
long ltrunc(const T& v);
#ifdef BOOST_HAS_LONG_LONG
template <class T, class Policy>
boost::long_long_type lltrunc(const T& v, const Policy& pol);
template <class T>
boost::long_long_type lltrunc(const T& v);
#endif
template <class T, class Policy>
typename tools::promote_args<T>::type round(const T& v, const Policy& pol);
template <class T>
typename tools::promote_args<T>::type round(const T& v);
template <class T, class Policy>
int iround(const T& v, const Policy& pol);
template <class T>
int iround(const T& v);
template <class T, class Policy>
long lround(const T& v, const Policy& pol);
template <class T>
long lround(const T& v);
#ifdef BOOST_HAS_LONG_LONG
template <class T, class Policy>
boost::long_long_type llround(const T& v, const Policy& pol);
template <class T>
boost::long_long_type llround(const T& v);
#endif
template <class T, class Policy>
T modf(const T& v, T* ipart, const Policy& pol);
template <class T>
T modf(const T& v, T* ipart);
template <class T, class Policy>
T modf(const T& v, int* ipart, const Policy& pol);
template <class T>
T modf(const T& v, int* ipart);
template <class T, class Policy>
T modf(const T& v, long* ipart, const Policy& pol);
template <class T>
T modf(const T& v, long* ipart);
#ifdef BOOST_HAS_LONG_LONG
template <class T, class Policy>
T modf(const T& v, boost::long_long_type* ipart, const Policy& pol);
template <class T>
T modf(const T& v, boost::long_long_type* ipart);
#endif
}
}
#undef BOOST_MATH_STD_USING
#define BOOST_MATH_STD_USING BOOST_MATH_STD_USING_CORE\
using boost::math::round;\
using boost::math::iround;\
using boost::math::lround;\
using boost::math::trunc;\
using boost::math::itrunc;\
using boost::math::ltrunc;\
using boost::math::modf;
#endif // BOOST_MATH_SPECIAL_ROUND_FWD_HPP

640
3rdparty/boost/boost/math/special_functions/fpclassify.hpp vendored
View File

@ -1,640 +0,0 @@
// Copyright John Maddock 2005-2008.
// Copyright (c) 2006-2008 Johan Rade
// Use, modification and distribution are 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)
#ifndef BOOST_MATH_FPCLASSIFY_HPP
#define BOOST_MATH_FPCLASSIFY_HPP
#ifdef _MSC_VER
#pragma once
#endif
#include <math.h>
#include <boost/config/no_tr1/cmath.hpp>
#include <boost/limits.hpp>
#include <boost/math/tools/real_cast.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/math/special_functions/math_fwd.hpp>
#include <boost/math/special_functions/detail/fp_traits.hpp>
/*!
\file fpclassify.hpp
\brief Classify floating-point value as normal, subnormal, zero, infinite, or NaN.
\version 1.0
\author John Maddock
*/
/*
1. If the platform is C99 compliant, then the native floating point
classification functions are used. However, note that we must only
define the functions which call std::fpclassify etc if that function
really does exist: otherwise a compiler may reject the code even though
the template is never instantiated.
2. If the platform is not C99 compliant, and the binary format for
a floating point type (float, double or long double) can be determined
at compile time, then the following algorithm is used:
If all exponent bits, the flag bit (if there is one),
and all significand bits are 0, then the number is zero.
If all exponent bits and the flag bit (if there is one) are 0,
and at least one significand bit is 1, then the number is subnormal.
If all exponent bits are 1 and all significand bits are 0,
then the number is infinity.
If all exponent bits are 1 and at least one significand bit is 1,
then the number is a not-a-number.
Otherwise the number is normal.
This algorithm works for the IEEE 754 representation,
and also for several non IEEE 754 formats.
Most formats have the structure
sign bit + exponent bits + significand bits.
A few have the structure
sign bit + exponent bits + flag bit + significand bits.
The flag bit is 0 for zero and subnormal numbers,
and 1 for normal numbers and NaN.
It is 0 (Motorola 68K) or 1 (Intel) for infinity.
To get the bits, the four or eight most significant bytes are copied
into an uint32_t or uint64_t and bit masks are applied.
This covers all the exponent bits and the flag bit (if there is one),
but not always all the significand bits.
Some of the functions below have two implementations,
depending on whether all the significand bits are copied or not.
3. If the platform is not C99 compliant, and the binary format for
a floating point type (float, double or long double) can not be determined
at compile time, then comparison with std::numeric_limits values
is used.
*/
#if defined(_MSC_VER) || defined(__BORLANDC__)
#include <float.h>
#endif
#ifdef BOOST_MATH_USE_FLOAT128
#ifdef __has_include
#if __has_include("quadmath.h")
#include "quadmath.h"
#define BOOST_MATH_HAS_QUADMATH_H
#endif
#endif
#endif
#ifdef BOOST_NO_STDC_NAMESPACE
namespace std{ using ::abs; using ::fabs; }
#endif
namespace boost{
//
// This must not be located in any namespace under boost::math
// otherwise we can get into an infinite loop if isnan is
// a #define for "isnan" !
//
namespace math_detail{
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable:4800)
#endif
template <class T>
inline bool is_nan_helper(T t, const boost::true_type&)
{
#ifdef isnan
return isnan(t);
#elif defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY) || !defined(BOOST_HAS_FPCLASSIFY)
(void)t;
return false;
#else // BOOST_HAS_FPCLASSIFY
return (BOOST_FPCLASSIFY_PREFIX fpclassify(t) == (int)FP_NAN);
#endif
}
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
template <class T>
inline bool is_nan_helper(T, const boost::false_type&)
{
return false;
}
#if defined(BOOST_MATH_USE_FLOAT128)
#if defined(BOOST_MATH_HAS_QUADMATH_H)
inline bool is_nan_helper(__float128 f, const boost::true_type&) { return ::isnanq(f); }
inline bool is_nan_helper(__float128 f, const boost::false_type&) { return ::isnanq(f); }
#elif defined(BOOST_GNU_STDLIB) && BOOST_GNU_STDLIB && \
_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
inline bool is_nan_helper(__float128 f, const boost::true_type&) { return std::isnan(static_cast<double>(f)); }
inline bool is_nan_helper(__float128 f, const boost::false_type&) { return std::isnan(static_cast<double>(f)); }
#else
inline bool is_nan_helper(__float128 f, const boost::true_type&) { return ::isnan(static_cast<double>(f)); }
inline bool is_nan_helper(__float128 f, const boost::false_type&) { return ::isnan(static_cast<double>(f)); }
#endif
#endif
}
namespace math{
namespace detail{
#ifdef BOOST_MATH_USE_STD_FPCLASSIFY
template <class T>
inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const native_tag&)
{
return (std::fpclassify)(t);
}
#endif
template <class T>
inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const generic_tag<true>&)
{
BOOST_MATH_INSTRUMENT_VARIABLE(t);
// whenever possible check for Nan's first:
#if defined(BOOST_HAS_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)
if(::boost::math_detail::is_nan_helper(t, ::boost::is_floating_point<T>()))
return FP_NAN;
#elif defined(isnan)
if(boost::math_detail::is_nan_helper(t, ::boost::is_floating_point<T>()))
return FP_NAN;
#elif defined(_MSC_VER) || defined(__BORLANDC__)
if(::_isnan(boost::math::tools::real_cast<double>(t)))
return FP_NAN;
#endif
// std::fabs broken on a few systems especially for long long!!!!
T at = (t < T(0)) ? -t : t;
// Use a process of exclusion to figure out
// what kind of type we have, this relies on
// IEEE conforming reals that will treat
// Nan's as unordered. Some compilers
// don't do this once optimisations are
// turned on, hence the check for nan's above.
if(at <= (std::numeric_limits<T>::max)())
{
if(at >= (std::numeric_limits<T>::min)())
return FP_NORMAL;
return (at != 0) ? FP_SUBNORMAL : FP_ZERO;
}
else if(at > (std::numeric_limits<T>::max)())
return FP_INFINITE;
return FP_NAN;
}
template <class T>
inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const generic_tag<false>&)
{
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<T>::is_specialized)
return fpclassify_imp(t, generic_tag<true>());
#endif
//
// An unknown type with no numeric_limits support,
// so what are we supposed to do we do here?
//
BOOST_MATH_INSTRUMENT_VARIABLE(t);
return t == 0 ? FP_ZERO : FP_NORMAL;
}
template<class T>
int fpclassify_imp BOOST_NO_MACRO_EXPAND(T x, ieee_copy_all_bits_tag)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_MATH_INSTRUMENT_VARIABLE(x);
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
BOOST_MATH_INSTRUMENT_VARIABLE(a);
a &= traits::exponent | traits::flag | traits::significand;
BOOST_MATH_INSTRUMENT_VARIABLE((traits::exponent | traits::flag | traits::significand));
BOOST_MATH_INSTRUMENT_VARIABLE(a);
if(a <= traits::significand) {
if(a == 0)
return FP_ZERO;
else
return FP_SUBNORMAL;
}
if(a < traits::exponent) return FP_NORMAL;
a &= traits::significand;
if(a == 0) return FP_INFINITE;
return FP_NAN;
}
template<class T>
int fpclassify_imp BOOST_NO_MACRO_EXPAND(T x, ieee_copy_leading_bits_tag)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_MATH_INSTRUMENT_VARIABLE(x);
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a &= traits::exponent | traits::flag | traits::significand;
if(a <= traits::significand) {
if(x == 0)
return FP_ZERO;
else
return FP_SUBNORMAL;
}
if(a < traits::exponent) return FP_NORMAL;
a &= traits::significand;
traits::set_bits(x,a);
if(x == 0) return FP_INFINITE;
return FP_NAN;
}
#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && (defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) || defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS))
inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(long double t, const native_tag&)
{
return boost::math::detail::fpclassify_imp(t, generic_tag<true>());
}
#endif
} // namespace detail
template <class T>
inline int fpclassify BOOST_NO_MACRO_EXPAND(T t)
{
typedef typename detail::fp_traits<T>::type traits;
typedef typename traits::method method;
typedef typename tools::promote_args_permissive<T>::type value_type;
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<T>::is_specialized && detail::is_generic_tag_false(static_cast<method*>(0)))
return detail::fpclassify_imp(static_cast<value_type>(t), detail::generic_tag<true>());
return detail::fpclassify_imp(static_cast<value_type>(t), method());
#else
return detail::fpclassify_imp(static_cast<value_type>(t), method());
#endif
}
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
template <>
inline int fpclassify<long double> BOOST_NO_MACRO_EXPAND(long double t)
{
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
typedef long double value_type;
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<long double>::is_specialized && detail::is_generic_tag_false(static_cast<method*>(0)))
return detail::fpclassify_imp(static_cast<value_type>(t), detail::generic_tag<true>());
return detail::fpclassify_imp(static_cast<value_type>(t), method());
#else
return detail::fpclassify_imp(static_cast<value_type>(t), method());
#endif
}
#endif
namespace detail {
#ifdef BOOST_MATH_USE_STD_FPCLASSIFY
template<class T>
inline bool isfinite_impl(T x, native_tag const&)
{
return (std::isfinite)(x);
}
#endif
template<class T>
inline bool isfinite_impl(T x, generic_tag<true> const&)
{
return x >= -(std::numeric_limits<T>::max)()
&& x <= (std::numeric_limits<T>::max)();
}
template<class T>
inline bool isfinite_impl(T x, generic_tag<false> const&)
{
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<T>::is_specialized)
return isfinite_impl(x, generic_tag<true>());
#endif
(void)x; // warning suppression.
return true;
}
template<class T>
inline bool isfinite_impl(T x, ieee_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a &= traits::exponent;
return a != traits::exponent;
}
#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY)
inline bool isfinite_impl BOOST_NO_MACRO_EXPAND(long double t, const native_tag&)
{
return boost::math::detail::isfinite_impl(t, generic_tag<true>());
}
#endif
}
template<class T>
inline bool (isfinite)(T x)
{ //!< \brief return true if floating-point type t is finite.
typedef typename detail::fp_traits<T>::type traits;
typedef typename traits::method method;
// typedef typename boost::is_floating_point<T>::type fp_tag;
typedef typename tools::promote_args_permissive<T>::type value_type;
return detail::isfinite_impl(static_cast<value_type>(x), method());
}
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
template<>
inline bool (isfinite)(long double x)
{ //!< \brief return true if floating-point type t is finite.
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
//typedef boost::is_floating_point<long double>::type fp_tag;
typedef long double value_type;
return detail::isfinite_impl(static_cast<value_type>(x), method());
}
#endif
//------------------------------------------------------------------------------
namespace detail {
#ifdef BOOST_MATH_USE_STD_FPCLASSIFY
template<class T>
inline bool isnormal_impl(T x, native_tag const&)
{
return (std::isnormal)(x);
}
#endif
template<class T>
inline bool isnormal_impl(T x, generic_tag<true> const&)
{
if(x < 0) x = -x;
return x >= (std::numeric_limits<T>::min)()
&& x <= (std::numeric_limits<T>::max)();
}
template<class T>
inline bool isnormal_impl(T x, generic_tag<false> const&)
{
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<T>::is_specialized)
return isnormal_impl(x, generic_tag<true>());
#endif
return !(x == 0);
}
template<class T>
inline bool isnormal_impl(T x, ieee_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME detail::fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a &= traits::exponent | traits::flag;
return (a != 0) && (a < traits::exponent);
}
#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY)
inline bool isnormal_impl BOOST_NO_MACRO_EXPAND(long double t, const native_tag&)
{
return boost::math::detail::isnormal_impl(t, generic_tag<true>());
}
#endif
}
template<class T>
inline bool (isnormal)(T x)
{
typedef typename detail::fp_traits<T>::type traits;
typedef typename traits::method method;
//typedef typename boost::is_floating_point<T>::type fp_tag;
typedef typename tools::promote_args_permissive<T>::type value_type;
return detail::isnormal_impl(static_cast<value_type>(x), method());
}
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
template<>
inline bool (isnormal)(long double x)
{
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
//typedef boost::is_floating_point<long double>::type fp_tag;
typedef long double value_type;
return detail::isnormal_impl(static_cast<value_type>(x), method());
}
#endif
//------------------------------------------------------------------------------
namespace detail {
#ifdef BOOST_MATH_USE_STD_FPCLASSIFY
template<class T>
inline bool isinf_impl(T x, native_tag const&)
{
return (std::isinf)(x);
}
#endif
template<class T>
inline bool isinf_impl(T x, generic_tag<true> const&)
{
(void)x; // in case the compiler thinks that x is unused because std::numeric_limits<T>::has_infinity is false
return std::numeric_limits<T>::has_infinity
&& ( x == std::numeric_limits<T>::infinity()
|| x == -std::numeric_limits<T>::infinity());
}
template<class T>
inline bool isinf_impl(T x, generic_tag<false> const&)
{
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<T>::is_specialized)
return isinf_impl(x, generic_tag<true>());
#endif
(void)x; // warning suppression.
return false;
}
template<class T>
inline bool isinf_impl(T x, ieee_copy_all_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a &= traits::exponent | traits::significand;
return a == traits::exponent;
}
template<class T>
inline bool isinf_impl(T x, ieee_copy_leading_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a &= traits::exponent | traits::significand;
if(a != traits::exponent)
return false;
traits::set_bits(x,0);
return x == 0;
}
#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY)
inline bool isinf_impl BOOST_NO_MACRO_EXPAND(long double t, const native_tag&)
{
return boost::math::detail::isinf_impl(t, generic_tag<true>());
}
#endif
} // namespace detail
template<class T>
inline bool (isinf)(T x)
{
typedef typename detail::fp_traits<T>::type traits;
typedef typename traits::method method;
// typedef typename boost::is_floating_point<T>::type fp_tag;
typedef typename tools::promote_args_permissive<T>::type value_type;
return detail::isinf_impl(static_cast<value_type>(x), method());
}
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
template<>
inline bool (isinf)(long double x)
{
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
//typedef boost::is_floating_point<long double>::type fp_tag;
typedef long double value_type;
return detail::isinf_impl(static_cast<value_type>(x), method());
}
#endif
#if defined(BOOST_MATH_USE_FLOAT128) && defined(BOOST_MATH_HAS_QUADMATH_H)
template<>
inline bool (isinf)(__float128 x)
{
return ::isinfq(x);
}
#endif
//------------------------------------------------------------------------------
namespace detail {
#ifdef BOOST_MATH_USE_STD_FPCLASSIFY
template<class T>
inline bool isnan_impl(T x, native_tag const&)
{
return (std::isnan)(x);
}
#endif
template<class T>
inline bool isnan_impl(T x, generic_tag<true> const&)
{
return std::numeric_limits<T>::has_infinity
? !(x <= std::numeric_limits<T>::infinity())
: x != x;
}
template<class T>
inline bool isnan_impl(T x, generic_tag<false> const&)
{
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
if(std::numeric_limits<T>::is_specialized)
return isnan_impl(x, generic_tag<true>());
#endif
(void)x; // warning suppression
return false;
}
template<class T>
inline bool isnan_impl(T x, ieee_copy_all_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a &= traits::exponent | traits::significand;
return a > traits::exponent;
}
template<class T>
inline bool isnan_impl(T x, ieee_copy_leading_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a &= traits::exponent | traits::significand;
if(a < traits::exponent)
return false;
a &= traits::significand;
traits::set_bits(x,a);
return x != 0;
}
} // namespace detail
template<class T>
inline bool (isnan)(T x)
{ //!< \brief return true if floating-point type t is NaN (Not A Number).
typedef typename detail::fp_traits<T>::type traits;
typedef typename traits::method method;
// typedef typename boost::is_floating_point<T>::type fp_tag;
return detail::isnan_impl(x, method());
}
#ifdef isnan
template <> inline bool isnan BOOST_NO_MACRO_EXPAND<float>(float t){ return ::boost::math_detail::is_nan_helper(t, boost::true_type()); }
template <> inline bool isnan BOOST_NO_MACRO_EXPAND<double>(double t){ return ::boost::math_detail::is_nan_helper(t, boost::true_type()); }
template <> inline bool isnan BOOST_NO_MACRO_EXPAND<long double>(long double t){ return ::boost::math_detail::is_nan_helper(t, boost::true_type()); }
#elif defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
template<>
inline bool (isnan)(long double x)
{ //!< \brief return true if floating-point type t is NaN (Not A Number).
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
//typedef boost::is_floating_point<long double>::type fp_tag;
return detail::isnan_impl(x, method());
}
#endif
#if defined(BOOST_MATH_USE_FLOAT128) && defined(BOOST_MATH_HAS_QUADMATH_H)
template<>
inline bool (isnan)(__float128 x)
{
return ::isnanq(x);
}
#endif
} // namespace math
} // namespace boost
#endif // BOOST_MATH_FPCLASSIFY_HPP

1712
3rdparty/boost/boost/math/special_functions/math_fwd.hpp vendored
View File

File diff suppressed because it is too large Load Diff

194
3rdparty/boost/boost/math/special_functions/sign.hpp vendored
View File

@ -1,194 +0,0 @@
// (C) Copyright John Maddock 2006.
// (C) Copyright Johan Rade 2006.
// (C) Copyright Paul A. Bristow 2011 (added changesign).
// Use, modification and distribution are 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)
#ifndef BOOST_MATH_TOOLS_SIGN_HPP
#define BOOST_MATH_TOOLS_SIGN_HPP
#ifdef _MSC_VER
#pragma once
#endif
#include <boost/math/tools/config.hpp>
#include <boost/math/special_functions/math_fwd.hpp>
#include <boost/math/special_functions/detail/fp_traits.hpp>
namespace boost{ namespace math{
namespace detail {
// signbit
#ifdef BOOST_MATH_USE_STD_FPCLASSIFY
template<class T>
inline int signbit_impl(T x, native_tag const&)
{
return (std::signbit)(x) ? 1 : 0;
}
#endif
// Generic versions first, note that these do not handle
// signed zero or NaN.
template<class T>
inline int signbit_impl(T x, generic_tag<true> const&)
{
return x < 0;
}
template<class T>
inline int signbit_impl(T x, generic_tag<false> const&)
{
return x < 0;
}
#if defined(__GNUC__) && (LDBL_MANT_DIG == 106)
//
// Special handling for GCC's "double double" type,
// in this case the sign is the same as the sign we
// get by casting to double, no overflow/underflow
// can occur since the exponents are the same magnitude
// for the two types:
//
inline int signbit_impl(long double x, generic_tag<true> const&)
{
return (boost::math::signbit)(static_cast<double>(x));
}
inline int signbit_impl(long double x, generic_tag<false> const&)
{
return (boost::math::signbit)(static_cast<double>(x));
}
#endif
template<class T>
inline int signbit_impl(T x, ieee_copy_all_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
return a & traits::sign ? 1 : 0;
}
template<class T>
inline int signbit_impl(T x, ieee_copy_leading_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
return a & traits::sign ? 1 : 0;
}
// Changesign
// Generic versions first, note that these do not handle
// signed zero or NaN.
template<class T>
inline T (changesign_impl)(T x, generic_tag<true> const&)
{
return -x;
}
template<class T>
inline T (changesign_impl)(T x, generic_tag<false> const&)
{
return -x;
}
#if defined(__GNUC__) && (LDBL_MANT_DIG == 106)
//
// Special handling for GCC's "double double" type,
// in this case we need to change the sign of both
// components of the "double double":
//
inline long double (changesign_impl)(long double x, generic_tag<true> const&)
{
double* pd = reinterpret_cast<double*>(&x);
pd[0] = boost::math::changesign(pd[0]);
pd[1] = boost::math::changesign(pd[1]);
return x;
}
inline long double (changesign_impl)(long double x, generic_tag<false> const&)
{
double* pd = reinterpret_cast<double*>(&x);
pd[0] = boost::math::changesign(pd[0]);
pd[1] = boost::math::changesign(pd[1]);
return x;
}
#endif
template<class T>
inline T changesign_impl(T x, ieee_copy_all_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::sign_change_type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a ^= traits::sign;
traits::set_bits(x,a);
return x;
}
template<class T>
inline T (changesign_impl)(T x, ieee_copy_leading_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::sign_change_type traits;
BOOST_DEDUCED_TYPENAME traits::bits a;
traits::get_bits(x,a);
a ^= traits::sign;
traits::set_bits(x,a);
return x;
}
} // namespace detail
template<class T> int (signbit)(T x)
{
typedef typename detail::fp_traits<T>::type traits;
typedef typename traits::method method;
// typedef typename boost::is_floating_point<T>::type fp_tag;
typedef typename tools::promote_args_permissive<T>::type result_type;
return detail::signbit_impl(static_cast<result_type>(x), method());
}
template <class T>
inline int sign BOOST_NO_MACRO_EXPAND(const T& z)
{
return (z == 0) ? 0 : (boost::math::signbit)(z) ? -1 : 1;
}
template <class T> typename tools::promote_args_permissive<T>::type (changesign)(const T& x)
{ //!< \brief return unchanged binary pattern of x, except for change of sign bit.
typedef typename detail::fp_traits<T>::sign_change_type traits;
typedef typename traits::method method;
// typedef typename boost::is_floating_point<T>::type fp_tag;
typedef typename tools::promote_args_permissive<T>::type result_type;
return detail::changesign_impl(static_cast<result_type>(x), method());
}
template <class T, class U>
inline typename tools::promote_args_permissive<T, U>::type
copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y)
{
BOOST_MATH_STD_USING
typedef typename tools::promote_args_permissive<T, U>::type result_type;
return (boost::math::signbit)(static_cast<result_type>(x)) != (boost::math::signbit)(static_cast<result_type>(y))
? (boost::math::changesign)(static_cast<result_type>(x)) : static_cast<result_type>(x);
}
} // namespace math
} // namespace boost
#endif // BOOST_MATH_TOOLS_SIGN_HPP

469
3rdparty/boost/boost/math/tools/config.hpp vendored
View File

@ -1,469 +0,0 @@
// Copyright (c) 2006-7 John Maddock
// Use, modification and distribution are 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)
#ifndef BOOST_MATH_TOOLS_CONFIG_HPP
#define BOOST_MATH_TOOLS_CONFIG_HPP
#ifdef _MSC_VER
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/predef/architecture/x86.h>
#include <boost/cstdint.hpp> // for boost::uintmax_t
#include <boost/detail/workaround.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <algorithm> // for min and max
#include <boost/config/no_tr1/cmath.hpp>
#include <climits>
#include <cfloat>
#if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
# include <math.h>
#endif
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
# include <limits>
#endif
#include <boost/math/tools/user.hpp>
#if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \
|| (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \
&& !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
# define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
#endif
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
//
// Borland post 5.8.2 uses Dinkumware's std C lib which
// doesn't have true long double precision. Earlier
// versions are problematic too:
//
# define BOOST_MATH_NO_REAL_CONCEPT_TESTS
# define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
# define BOOST_MATH_CONTROL_FP _control87(MCW_EM,MCW_EM)
# include <float.h>
#endif
#ifdef __IBMCPP__
//
// For reasons I don't unserstand, the tests with IMB's compiler all
// pass at long double precision, but fail with real_concept, those tests
// are disabled for now. (JM 2012).
# define BOOST_MATH_NO_REAL_CONCEPT_TESTS
#endif
#ifdef sun
// Any use of __float128 in program startup code causes a segfault (tested JM 2015, Solaris 11).
# define BOOST_MATH_DISABLE_FLOAT128
#endif
#ifdef __HAIKU__
//
// Not sure what's up with the math detection on Haiku, but linking fails with
// float128 code enabled, and we don't have an implementation of __expl, so
// disabling long double functions for now as well.
# define BOOST_MATH_DISABLE_FLOAT128
# define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
#endif
#if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) && ((LDBL_MANT_DIG == 106) || (__LDBL_MANT_DIG__ == 106)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
//
// Darwin's rather strange "double double" is rather hard to
// support, it should be possible given enough effort though...
//
# define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
#endif
#if defined(unix) && defined(__INTEL_COMPILER) && (__INTEL_COMPILER <= 1000) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
//
// Intel compiler prior to version 10 has sporadic problems
// calling the long double overloads of the std lib math functions:
// calling ::powl is OK, but std::pow(long double, long double)
// may segfault depending upon the value of the arguments passed
// and the specific Linux distribution.
//
// We'll be conservative and disable long double support for this compiler.
//
// Comment out this #define and try building the tests to determine whether
// your Intel compiler version has this issue or not.
//
# define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
#endif
#if defined(unix) && defined(__INTEL_COMPILER)
//
// Intel compiler has sporadic issues compiling std::fpclassify depending on
// the exact OS version used. Use our own code for this as we know it works
// well on Intel processors:
//
#define BOOST_MATH_DISABLE_STD_FPCLASSIFY
#endif
#if defined(BOOST_MSVC) && !defined(_WIN32_WCE)
// Better safe than sorry, our tests don't support hardware exceptions:
# define BOOST_MATH_CONTROL_FP _control87(MCW_EM,MCW_EM)
#endif
#ifdef __IBMCPP__
# define BOOST_MATH_NO_DEDUCED_FUNCTION_POINTERS
#endif
#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901))
# define BOOST_MATH_USE_C99
#endif
#if (defined(__hpux) && !defined(__hppa))
# define BOOST_MATH_USE_C99
#endif
#if defined(__GNUC__) && defined(_GLIBCXX_USE_C99)
# define BOOST_MATH_USE_C99
#endif
#if defined(_LIBCPP_VERSION) && !defined(_MSC_VER)
# define BOOST_MATH_USE_C99
#endif
#if defined(__CYGWIN__) || defined(__HP_aCC) || defined(BOOST_INTEL) \
|| defined(BOOST_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) \
|| (defined(__GNUC__) && !defined(BOOST_MATH_USE_C99))\
|| defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
# define BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY
#endif
#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
# include "boost/type.hpp"
# include "boost/non_type.hpp"
# define BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(t) boost::type<t>* = 0
# define BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type<t>*
# define BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type<t, v>* = 0
# define BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) boost::non_type<t, v>*
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \
, BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(t)
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \
, BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \
, BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \
, BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
#else
// no workaround needed: expand to nothing
# define BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(t)
# define BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
# define BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
# define BOOST_MATH_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
#endif // __SUNPRO_CC
#if (defined(__SUNPRO_CC) || defined(__hppa) || defined(__GNUC__)) && !defined(BOOST_MATH_SMALL_CONSTANT)
// Sun's compiler emits a hard error if a constant underflows,
// as does aCC on PA-RISC, while gcc issues a large number of warnings:
# define BOOST_MATH_SMALL_CONSTANT(x) 0.0
#else
# define BOOST_MATH_SMALL_CONSTANT(x) x
#endif
#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
//
// Define if constants too large for a float cause "bad"
// values to be stored in the data, rather than infinity
// or a suitably large value.
//
# define BOOST_MATH_BUGGY_LARGE_FLOAT_CONSTANTS
#endif
//
// Tune performance options for specific compilers:
//
#ifdef BOOST_MSVC
# define BOOST_MATH_POLY_METHOD 2
# define BOOST_MATH_RATIONAL_METHOD 1
#elif defined(BOOST_INTEL)
# define BOOST_MATH_POLY_METHOD 2
# define BOOST_MATH_RATIONAL_METHOD 1
#elif defined(__GNUC__)
#if __GNUC__ < 4
# define BOOST_MATH_POLY_METHOD 3
# define BOOST_MATH_RATIONAL_METHOD 3
# define BOOST_MATH_INT_TABLE_TYPE(RT, IT) RT
# define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##.0L
#else
# define BOOST_MATH_POLY_METHOD 3
# define BOOST_MATH_RATIONAL_METHOD 1
#endif
#endif
#if defined(BOOST_NO_LONG_LONG) && !defined(BOOST_MATH_INT_TABLE_TYPE)
# define BOOST_MATH_INT_TABLE_TYPE(RT, IT) RT
# define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##.0L
#endif
//
// constexpr support, early GCC implementations can't cope so disable
// constexpr for them:
//
#if !defined(__clang__) && defined(__GNUC__)
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 490
# define BOOST_MATH_DISABLE_CONSTEXPR
#endif
#endif
#ifdef BOOST_MATH_DISABLE_CONSTEXPR
# define BOOST_MATH_CONSTEXPR
#else
# define BOOST_MATH_CONSTEXPR BOOST_CONSTEXPR
#endif
//
// noexcept support:
//
#ifndef BOOST_NO_CXX11_NOEXCEPT
#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
#include <type_traits>
# define BOOST_MATH_NOEXCEPT(T) noexcept(std::is_floating_point<T>::value)
# define BOOST_MATH_IS_FLOAT(T) (std::is_floating_point<T>::value)
#else
#include <boost/type_traits/is_floating_point.hpp>
# define BOOST_MATH_NOEXCEPT(T) noexcept(boost::is_floating_point<T>::value)
# define BOOST_MATH_IS_FLOAT(T) (boost::is_floating_point<T>::value)
#endif
#else
# define BOOST_MATH_NOEXCEPT(T)
# define BOOST_MATH_IS_FLOAT(T) false
#endif
//
// The maximum order of polynomial that will be evaluated
// via an unrolled specialisation:
//
#ifndef BOOST_MATH_MAX_POLY_ORDER
# define BOOST_MATH_MAX_POLY_ORDER 20
#endif
//
// Set the method used to evaluate polynomials and rationals:
//
#ifndef BOOST_MATH_POLY_METHOD
# define BOOST_MATH_POLY_METHOD 2
#endif
#ifndef BOOST_MATH_RATIONAL_METHOD
# define BOOST_MATH_RATIONAL_METHOD 1
#endif
//
// decide whether to store constants as integers or reals:
//
#ifndef BOOST_MATH_INT_TABLE_TYPE
# define BOOST_MATH_INT_TABLE_TYPE(RT, IT) IT
#endif
#ifndef BOOST_MATH_INT_VALUE_SUFFIX
# define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##SUF
#endif
//
// And then the actual configuration:
//
#if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__) \
&& !defined(BOOST_MATH_DISABLE_FLOAT128) || defined(BOOST_MATH_USE_FLOAT128)
//
// Only enable this when the compiler really is GCC as clang and probably
// intel too don't support __float128 yet :-(
//
#ifndef BOOST_MATH_USE_FLOAT128
# define BOOST_MATH_USE_FLOAT128
#endif
# if defined(BOOST_INTEL) && defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION >= 1310) && defined(__GNUC__)
# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))
# define BOOST_MATH_FLOAT128_TYPE __float128
# endif
# elif defined(__GNUC__)
# define BOOST_MATH_FLOAT128_TYPE __float128
# endif
# ifndef BOOST_MATH_FLOAT128_TYPE
# define BOOST_MATH_FLOAT128_TYPE _Quad
# endif
#endif
//
// Check for WinCE with no iostream support:
//
#if defined(_WIN32_WCE) && !defined(__SGI_STL_PORT)
# define BOOST_MATH_NO_LEXICAL_CAST
#endif
//
// Helper macro for controlling the FP behaviour:
//
#ifndef BOOST_MATH_CONTROL_FP
# define BOOST_MATH_CONTROL_FP
#endif
//
// Helper macro for using statements:
//
#define BOOST_MATH_STD_USING_CORE \
using std::abs;\
using std::acos;\
using std::cos;\
using std::fmod;\
using std::modf;\
using std::tan;\
using std::asin;\
using std::cosh;\
using std::frexp;\
using std::pow;\
using std::tanh;\
using std::atan;\
using std::exp;\
using std::ldexp;\
using std::sin;\
using std::atan2;\
using std::fabs;\
using std::log;\
using std::sinh;\
using std::ceil;\
using std::floor;\
using std::log10;\
using std::sqrt;
#define BOOST_MATH_STD_USING BOOST_MATH_STD_USING_CORE
namespace boost{ namespace math{
namespace tools
{
template <class T>
inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c) BOOST_MATH_NOEXCEPT(T)
{
return (std::max)((std::max)(a, b), c);
}
template <class T>
inline T max BOOST_PREVENT_MACRO_SUBSTITUTION(T a, T b, T c, T d) BOOST_MATH_NOEXCEPT(T)
{
return (std::max)((std::max)(a, b), (std::max)(c, d));
}
} // namespace tools
template <class T>
void suppress_unused_variable_warning(const T&) BOOST_MATH_NOEXCEPT(T)
{
}
namespace detail{
template <class T>
struct is_integer_for_rounding
{
static const bool value = boost::is_integral<T>::value
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|| (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer)
#endif
;
};
}
}} // namespace boost namespace math
#ifdef __GLIBC_PREREQ
# if __GLIBC_PREREQ(2,14)
# define BOOST_MATH_HAVE_FIXED_GLIBC
# endif
#endif
#if ((defined(__linux__) && !defined(__UCLIBC__) && !defined(BOOST_MATH_HAVE_FIXED_GLIBC)) || defined(__QNX__) || defined(__IBMCPP__)) && !defined(BOOST_NO_FENV_H)
//
// This code was introduced in response to this glibc bug: http://sourceware.org/bugzilla/show_bug.cgi?id=2445
// Basically powl and expl can return garbage when the result is small and certain exception flags are set
// on entrance to these functions. This appears to have been fixed in Glibc 2.14 (May 2011).
// Much more information in this message thread: https://groups.google.com/forum/#!topic/boost-list/ZT99wtIFlb4
//
#include <boost/detail/fenv.hpp>
# ifdef FE_ALL_EXCEPT
namespace boost{ namespace math{
namespace detail
{
struct fpu_guard
{
fpu_guard()
{
fegetexceptflag(&m_flags, FE_ALL_EXCEPT);
feclearexcept(FE_ALL_EXCEPT);
}
~fpu_guard()
{
fesetexceptflag(&m_flags, FE_ALL_EXCEPT);
}
private:
fexcept_t m_flags;
};
} // namespace detail
}} // namespaces
# define BOOST_FPU_EXCEPTION_GUARD boost::math::detail::fpu_guard local_guard_object;
# define BOOST_MATH_INSTRUMENT_FPU do{ fexcept_t cpu_flags; fegetexceptflag(&cpu_flags, FE_ALL_EXCEPT); BOOST_MATH_INSTRUMENT_VARIABLE(cpu_flags); } while(0);
# else
# define BOOST_FPU_EXCEPTION_GUARD
# define BOOST_MATH_INSTRUMENT_FPU
# endif
#else // All other platforms.
# define BOOST_FPU_EXCEPTION_GUARD
# define BOOST_MATH_INSTRUMENT_FPU
#endif
#ifdef BOOST_MATH_INSTRUMENT
# include <iostream>
# include <iomanip>
# include <typeinfo>
# define BOOST_MATH_INSTRUMENT_CODE(x) \
std::cout << std::setprecision(35) << __FILE__ << ":" << __LINE__ << " " << x << std::endl;
# define BOOST_MATH_INSTRUMENT_VARIABLE(name) BOOST_MATH_INSTRUMENT_CODE(BOOST_STRINGIZE(name) << " = " << name)
#else
# define BOOST_MATH_INSTRUMENT_CODE(x)
# define BOOST_MATH_INSTRUMENT_VARIABLE(name)
#endif
//
// Thread local storage:
//
#if !defined(BOOST_NO_CXX11_THREAD_LOCAL) && !defined(BOOST_INTEL)
# define BOOST_MATH_THREAD_LOCAL thread_local
#else
# define BOOST_MATH_THREAD_LOCAL
#endif
//
// Can we have constexpr tables?
//
#if (!defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_CXX14_CONSTEXPR)) || BOOST_WORKAROUND(BOOST_MSVC, >= 1910)
#define BOOST_MATH_HAVE_CONSTEXPR_TABLES
#define BOOST_MATH_CONSTEXPR_TABLE_FUNCTION constexpr
#else
#define BOOST_MATH_CONSTEXPR_TABLE_FUNCTION
#endif
#endif // BOOST_MATH_TOOLS_CONFIG_HPP

182
3rdparty/boost/boost/math/tools/promotion.hpp vendored
View File

@ -1,182 +0,0 @@
// boost\math\tools\promotion.hpp
// Copyright John Maddock 2006.
// Copyright Paul A. Bristow 2006.
// Use, modification and distribution are 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)
// Promote arguments functions to allow math functions to have arguments
// provided as integer OR real (floating-point, built-in or UDT)
// (called ArithmeticType in functions that use promotion)
// that help to reduce the risk of creating multiple instantiations.
// Allows creation of an inline wrapper that forwards to a foo(RT, RT) function,
// so you never get to instantiate any mixed foo(RT, IT) functions.
#ifndef BOOST_MATH_PROMOTION_HPP
#define BOOST_MATH_PROMOTION_HPP
#ifdef _MSC_VER
#pragma once
#endif
// Boost type traits:
#include <boost/math/tools/config.hpp>
#include <boost/type_traits/is_floating_point.hpp> // for boost::is_floating_point;
#include <boost/type_traits/is_integral.hpp> // for boost::is_integral
#include <boost/type_traits/is_convertible.hpp> // for boost::is_convertible
#include <boost/type_traits/is_same.hpp>// for boost::is_same
#include <boost/type_traits/remove_cv.hpp>// for boost::remove_cv
// Boost Template meta programming:
#include <boost/mpl/if.hpp> // for boost::mpl::if_c.
#include <boost/mpl/and.hpp> // for boost::mpl::if_c.
#include <boost/mpl/or.hpp> // for boost::mpl::if_c.
#include <boost/mpl/not.hpp> // for boost::mpl::if_c.
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
#include <boost/static_assert.hpp>
#endif
namespace boost
{
namespace math
{
namespace tools
{
// If either T1 or T2 is an integer type,
// pretend it was a double (for the purposes of further analysis).
// Then pick the wider of the two floating-point types
// as the actual signature to forward to.
// For example:
// foo(int, short) -> double foo(double, double);
// foo(int, float) -> double foo(double, double);
// Note: NOT float foo(float, float)
// foo(int, double) -> foo(double, double);
// foo(double, float) -> double foo(double, double);
// foo(double, float) -> double foo(double, double);
// foo(any-int-or-float-type, long double) -> foo(long double, long double);
// but ONLY float foo(float, float) is unchanged.
// So the only way to get an entirely float version is to call foo(1.F, 2.F),
// But since most (all?) the math functions convert to double internally,
// probably there would not be the hoped-for gain by using float here.
// This follows the C-compatible conversion rules of pow, etc
// where pow(int, float) is converted to pow(double, double).
template <class T>
struct promote_arg
{ // If T is integral type, then promote to double.
typedef typename mpl::if_<is_integral<T>, double, T>::type type;
};
// These full specialisations reduce mpl::if_ usage and speed up
// compilation:
template <> struct promote_arg<float> { typedef float type; };
template <> struct promote_arg<double>{ typedef double type; };
template <> struct promote_arg<long double> { typedef long double type; };
template <> struct promote_arg<int> { typedef double type; };
template <class T1, class T2>
struct promote_args_2
{ // Promote, if necessary, & pick the wider of the two floating-point types.
// for both parameter types, if integral promote to double.
typedef typename promote_arg<T1>::type T1P; // T1 perhaps promoted.
typedef typename promote_arg<T2>::type T2P; // T2 perhaps promoted.
typedef typename mpl::if_<
typename mpl::and_<is_floating_point<T1P>, is_floating_point<T2P> >::type, // both T1P and T2P are floating-point?
#ifdef BOOST_MATH_USE_FLOAT128
typename mpl::if_< typename mpl::or_<is_same<__float128, T1P>, is_same<__float128, T2P> >::type, // either long double?
__float128,
#endif
typename mpl::if_< typename mpl::or_<is_same<long double, T1P>, is_same<long double, T2P> >::type, // either long double?
long double, // then result type is long double.
typename mpl::if_< typename mpl::or_<is_same<double, T1P>, is_same<double, T2P> >::type, // either double?
double, // result type is double.
float // else result type is float.
>::type
#ifdef BOOST_MATH_USE_FLOAT128
>::type
#endif
>::type,
// else one or the other is a user-defined type:
typename mpl::if_< typename mpl::and_<mpl::not_<is_floating_point<T2P> >, ::boost::is_convertible<T1P, T2P> >, T2P, T1P>::type>::type type;
}; // promote_arg2
// These full specialisations reduce mpl::if_ usage and speed up
// compilation:
template <> struct promote_args_2<float, float> { typedef float type; };
template <> struct promote_args_2<double, double>{ typedef double type; };
template <> struct promote_args_2<long double, long double> { typedef long double type; };
template <> struct promote_args_2<int, int> { typedef double type; };
template <> struct promote_args_2<int, float> { typedef double type; };
template <> struct promote_args_2<float, int> { typedef double type; };
template <> struct promote_args_2<int, double> { typedef double type; };
template <> struct promote_args_2<double, int> { typedef double type; };
template <> struct promote_args_2<int, long double> { typedef long double type; };
template <> struct promote_args_2<long double, int> { typedef long double type; };
template <> struct promote_args_2<float, double> { typedef double type; };
template <> struct promote_args_2<double, float> { typedef double type; };
template <> struct promote_args_2<float, long double> { typedef long double type; };
template <> struct promote_args_2<long double, float> { typedef long double type; };
template <> struct promote_args_2<double, long double> { typedef long double type; };
template <> struct promote_args_2<long double, double> { typedef long double type; };
template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
struct promote_args
{
typedef typename promote_args_2<
typename remove_cv<T1>::type,
typename promote_args_2<
typename remove_cv<T2>::type,
typename promote_args_2<
typename remove_cv<T3>::type,
typename promote_args_2<
typename remove_cv<T4>::type,
typename promote_args_2<
typename remove_cv<T5>::type, typename remove_cv<T6>::type
>::type
>::type
>::type
>::type
>::type type;
#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
//
// Guard against use of long double if it's not supported:
//
BOOST_STATIC_ASSERT_MSG((0 == ::boost::is_same<type, long double>::value), "Sorry, but this platform does not have sufficient long double support for the special functions to be reliably implemented.");
#endif
};
//
// This struct is the same as above, but has no static assert on long double usage,
// it should be used only on functions that can be implemented for long double
// even when std lib support is missing or broken for that type.
//
template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
struct promote_args_permissive
{
typedef typename promote_args_2<
typename remove_cv<T1>::type,
typename promote_args_2<
typename remove_cv<T2>::type,
typename promote_args_2<
typename remove_cv<T3>::type,
typename promote_args_2<
typename remove_cv<T4>::type,
typename promote_args_2<
typename remove_cv<T5>::type, typename remove_cv<T6>::type
>::type
>::type
>::type
>::type
>::type type;
};
} // namespace tools
} // namespace math
} // namespace boost
#endif // BOOST_MATH_PROMOTION_HPP

31
3rdparty/boost/boost/math/tools/real_cast.hpp vendored
View File

@ -1,31 +0,0 @@
// Copyright John Maddock 2006.
// Use, modification and distribution are 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)
#ifndef BOOST_MATH_TOOLS_REAL_CAST_HPP
#define BOOST_MATH_TOOLS_REAL_CAST_HPP
#include <boost/math/tools/config.hpp>
#ifdef _MSC_VER
#pragma once
#endif
namespace boost{ namespace math
{
namespace tools
{
template <class To, class T>
inline BOOST_MATH_CONSTEXPR To real_cast(T t) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && BOOST_MATH_IS_FLOAT(To))
{
return static_cast<To>(t);
}
} // namespace tools
} // namespace math
} // namespace boost
#endif // BOOST_MATH_TOOLS_REAL_CAST_HPP

105
3rdparty/boost/boost/math/tools/user.hpp vendored
View File

@ -1,105 +0,0 @@
// Copyright John Maddock 2007.
// Copyright Paul A. Bristow 2007.
// Use, modification and distribution are 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)
#ifndef BOOST_MATH_TOOLS_USER_HPP
#define BOOST_MATH_TOOLS_USER_HPP
#ifdef _MSC_VER
#pragma once
#endif
// This file can be modified by the user to change the default policies.
// See "Changing the Policy Defaults" in documentation.
// define this if the platform has no long double functions,
// or if the long double versions have only double precision:
//
// #define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
//
// Performance tuning options:
//
// #define BOOST_MATH_POLY_METHOD 3
// #define BOOST_MATH_RATIONAL_METHOD 3
//
// The maximum order of polynomial that will be evaluated
// via an unrolled specialisation:
//
// #define BOOST_MATH_MAX_POLY_ORDER 17
//
// decide whether to store constants as integers or reals:
//
// #define BOOST_MATH_INT_TABLE_TYPE(RT, IT) IT
//
// Default policies follow:
//
// Domain errors:
//
// #define BOOST_MATH_DOMAIN_ERROR_POLICY throw_on_error
//
// Pole errors:
//
// #define BOOST_MATH_POLE_ERROR_POLICY throw_on_error
//
// Overflow Errors:
//
// #define BOOST_MATH_OVERFLOW_ERROR_POLICY throw_on_error
//
// Internal Evaluation Errors:
//
// #define BOOST_MATH_EVALUATION_ERROR_POLICY throw_on_error
//
// Underfow:
//
// #define BOOST_MATH_UNDERFLOW_ERROR_POLICY ignore_error
//
// Denorms:
//
// #define BOOST_MATH_DENORM_ERROR_POLICY ignore_error
//
// Max digits to use for internal calculations:
//
// #define BOOST_MATH_DIGITS10_POLICY 0
//
// Promote floats to doubles internally?
//
// #define BOOST_MATH_PROMOTE_FLOAT_POLICY true
//
// Promote doubles to long double internally:
//
// #define BOOST_MATH_PROMOTE_DOUBLE_POLICY true
//
// What do discrete quantiles return?
//
// #define BOOST_MATH_DISCRETE_QUANTILE_POLICY integer_round_outwards
//
// If a function is mathematically undefined
// (for example the Cauchy distribution has no mean),
// then do we stop the code from compiling?
//
// #define BOOST_MATH_ASSERT_UNDEFINED_POLICY true
//
// Maximum series iterstions permitted:
//
// #define BOOST_MATH_MAX_SERIES_ITERATION_POLICY 1000000
//
// Maximum root finding steps permitted:
//
// define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 200
//
// Enable use of __float128 in numeric constants:
//
// #define BOOST_MATH_USE_FLOAT128
//
// Disable use of __float128 in numeric_constants even if the compiler looks to support it:
//
// #define BOOST_MATH_DISABLE_FLOAT128
#endif // BOOST_MATH_TOOLS_USER_HPP

52
3rdparty/boost/boost/mpl/at.hpp vendored
View File

@ -1,52 +0,0 @@
#ifndef BOOST_MPL_AT_HPP_INCLUDED
#define BOOST_MPL_AT_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/aux_/at_impl.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/sequence_tag.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
namespace boost { namespace mpl {
template<
typename BOOST_MPL_AUX_NA_PARAM(Sequence)
, typename BOOST_MPL_AUX_NA_PARAM(N)
>
struct at
: at_impl< typename sequence_tag<Sequence>::type >
::template apply< Sequence,N >
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,at,(Sequence,N))
};
template<
typename Sequence
, BOOST_MPL_AUX_NTTP_DECL(long, N)
>
struct at_c
: at_impl< typename sequence_tag<Sequence>::type >
::template apply< Sequence,mpl::long_<N> >
{
};
BOOST_MPL_AUX_NA_SPEC(2, at)
}}
#endif // BOOST_MPL_AT_HPP_INCLUDED

24
3rdparty/boost/boost/mpl/at_fwd.hpp vendored
View File

@ -1,24 +0,0 @@
#ifndef BOOST_MPL_AT_FWD_HPP_INCLUDED
#define BOOST_MPL_AT_FWD_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
namespace boost { namespace mpl {
template< typename Tag > struct at_impl;
template< typename Sequence, typename N > struct at;
}}
#endif // BOOST_MPL_AT_FWD_HPP_INCLUDED

45
3rdparty/boost/boost/mpl/aux_/at_impl.hpp vendored
View File

@ -1,45 +0,0 @@
#ifndef BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED
#define BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/advance.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
namespace boost { namespace mpl {
// default implementation; conrete sequences might override it by
// specializing either the 'at_impl' or the primary 'at' template
template< typename Tag >
struct at_impl
{
template< typename Sequence, typename N > struct apply
{
typedef typename advance<
typename begin<Sequence>::type
, N
>::type iter_;
typedef typename deref<iter_>::type type;
};
};
BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, at_impl)
}}
#endif // BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED

38
3rdparty/boost/boost/mpl/aux_/config/typeof.hpp vendored
View File

@ -1,38 +0,0 @@
#ifndef BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2003-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/aux_/config/gcc.hpp>
#if !defined(BOOST_MPL_CFG_HAS_TYPEOF) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& ( defined(BOOST_MPL_CFG_GCC) && BOOST_MPL_CFG_GCC >= 0x0302 \
|| defined(__MWERKS__) && __MWERKS__ >= 0x3000 \
)
# define BOOST_MPL_CFG_HAS_TYPEOF
#endif
#if !defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& defined(BOOST_MPL_CFG_HAS_TYPEOF)
# define BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
#endif
#endif // BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED

61
3rdparty/boost/boost/mpl/aux_/contains_impl.hpp vendored
View File

@ -1,61 +0,0 @@
#ifndef BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED
// Copyright Eric Friedman 2002
// Copyright Aleksey Gurtovoy 2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/contains_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
#include <boost/mpl/aux_/config/forwarding.hpp>
#include <boost/mpl/aux_/config/static_constant.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace mpl {
template< typename Tag >
struct contains_impl
{
template< typename Sequence, typename T > struct apply
#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING)
: not_< is_same<
typename find<Sequence,T>::type
, typename end<Sequence>::type
> >
{
#else
{
typedef not_< is_same<
typename find<Sequence,T>::type
, typename end<Sequence>::type
> > type;
BOOST_STATIC_CONSTANT(bool, value =
(not_< is_same<
typename find<Sequence,T>::type
, typename end<Sequence>::type
> >::value)
);
#endif
};
};
BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,contains_impl)
}}
#endif // BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED

24
3rdparty/boost/boost/mpl/back_fwd.hpp vendored
View File

@ -1,24 +0,0 @@
#ifndef BOOST_MPL_BACK_FWD_HPP_INCLUDED
#define BOOST_MPL_BACK_FWD_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
namespace boost { namespace mpl {
template< typename Tag > struct back_impl;
template< typename Sequence > struct back;
}}
#endif // BOOST_MPL_BACK_FWD_HPP_INCLUDED

24
3rdparty/boost/boost/mpl/comparison.hpp vendored
View File

@ -1,24 +0,0 @@
#ifndef BOOST_MPL_COMPARISON_HPP_INCLUDED
#define BOOST_MPL_COMPARISON_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/not_equal_to.hpp>
#include <boost/mpl/less.hpp>
#include <boost/mpl/greater.hpp>
#include <boost/mpl/less_equal.hpp>
#include <boost/mpl/greater_equal.hpp>
#endif // BOOST_MPL_COMPARISON_HPP_INCLUDED

41
3rdparty/boost/boost/mpl/contains.hpp vendored
View File

@ -1,41 +0,0 @@
#ifndef BOOST_MPL_CONTAINS_HPP_INCLUDED
#define BOOST_MPL_CONTAINS_HPP_INCLUDED
// Copyright Eric Friedman 2002
// Copyright Aleksey Gurtovoy 2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/contains_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
#include <boost/mpl/aux_/contains_impl.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
namespace boost { namespace mpl {
template<
typename BOOST_MPL_AUX_NA_PARAM(Sequence)
, typename BOOST_MPL_AUX_NA_PARAM(T)
>
struct contains
: contains_impl< typename sequence_tag<Sequence>::type >
::template apply< Sequence,T >
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,contains,(Sequence,T))
};
BOOST_MPL_AUX_NA_SPEC(2, contains)
}}
#endif // BOOST_MPL_CONTAINS_HPP_INCLUDED

25
3rdparty/boost/boost/mpl/contains_fwd.hpp vendored
View File

@ -1,25 +0,0 @@
#ifndef BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED
#define BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED
// Copyright Eric Friedman 2002
// Copyright Aleksey Gurtovoy 2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
namespace boost { namespace mpl {
template< typename Tag > struct contains_impl;
template< typename Sequence, typename T > struct contains;
}}
#endif // BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED

38
3rdparty/boost/boost/mpl/find.hpp vendored
View File

@ -1,38 +0,0 @@
#ifndef BOOST_MPL_FIND_HPP_INCLUDED
#define BOOST_MPL_FIND_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2002
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/same_as.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
namespace boost { namespace mpl {
template<
typename BOOST_MPL_AUX_NA_PARAM(Sequence)
, typename BOOST_MPL_AUX_NA_PARAM(T)
>
struct find
: find_if< Sequence,same_as<T> >
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,find,(Sequence,T))
};
BOOST_MPL_AUX_NA_SPEC(2, find)
}}
#endif // BOOST_MPL_FIND_HPP_INCLUDED

21
3rdparty/boost/boost/mpl/greater.hpp vendored
View File

@ -1,21 +0,0 @@
#ifndef BOOST_MPL_GREATER_HPP_INCLUDED
#define BOOST_MPL_GREATER_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#define AUX778076_OP_NAME greater
#define AUX778076_OP_TOKEN >
#include <boost/mpl/aux_/comparison_op.hpp>
#endif // BOOST_MPL_GREATER_HPP_INCLUDED

21
3rdparty/boost/boost/mpl/greater_equal.hpp vendored
View File

@ -1,21 +0,0 @@
#ifndef BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED
#define BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#define AUX778076_OP_NAME greater_equal
#define AUX778076_OP_TOKEN >=
#include <boost/mpl/aux_/comparison_op.hpp>
#endif // BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED

21
3rdparty/boost/boost/mpl/less_equal.hpp vendored
View File

@ -1,21 +0,0 @@
#ifndef BOOST_MPL_LESS_EQUAL_HPP_INCLUDED
#define BOOST_MPL_LESS_EQUAL_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#define AUX778076_OP_NAME less_equal
#define AUX778076_OP_TOKEN <=
#include <boost/mpl/aux_/comparison_op.hpp>
#endif // BOOST_MPL_LESS_EQUAL_HPP_INCLUDED

21
3rdparty/boost/boost/mpl/limits/vector.hpp vendored
View File

@ -1,21 +0,0 @@
#ifndef BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED
#define BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#if !defined(BOOST_MPL_LIMIT_VECTOR_SIZE)
# define BOOST_MPL_LIMIT_VECTOR_SIZE 20
#endif
#endif // BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED

21
3rdparty/boost/boost/mpl/minus.hpp vendored
View File

@ -1,21 +0,0 @@
#ifndef BOOST_MPL_MINUS_HPP_INCLUDED
#define BOOST_MPL_MINUS_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#define AUX778076_OP_NAME minus
#define AUX778076_OP_TOKEN -
#include <boost/mpl/aux_/arithmetic_op.hpp>
#endif // BOOST_MPL_MINUS_HPP_INCLUDED

53
3rdparty/boost/boost/mpl/multiplies.hpp vendored
View File

@ -1,53 +0,0 @@
#ifndef BOOST_MPL_MULTIPLIES_HPP_INCLUDED
#define BOOST_MPL_MULTIPLIES_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/times.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/aux_/preprocessor/default_params.hpp>
#include <boost/mpl/aux_/preprocessor/params.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
// backward compatibility header, deprecated
namespace boost { namespace mpl {
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
# define AUX778076_OP_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY
#else
# define AUX778076_OP_ARITY 2
#endif
template<
BOOST_MPL_PP_DEFAULT_PARAMS(AUX778076_OP_ARITY, typename N, na)
>
struct multiplies
: times< BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) >
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(
AUX778076_OP_ARITY
, multiplies
, ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) )
)
};
BOOST_MPL_AUX_NA_SPEC(AUX778076_OP_ARITY, multiplies)
#undef AUX778076_OP_ARITY
}}
#endif // BOOST_MPL_MULTIPLIES_HPP_INCLUDED

21
3rdparty/boost/boost/mpl/not_equal_to.hpp vendored
View File

@ -1,21 +0,0 @@
#ifndef BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED
#define BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#define AUX778076_OP_NAME not_equal_to
#define AUX778076_OP_TOKEN !=
#include <boost/mpl/aux_/comparison_op.hpp>
#endif // BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED

24
3rdparty/boost/boost/mpl/pop_back_fwd.hpp vendored
View File

@ -1,24 +0,0 @@
#ifndef BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED
#define BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
namespace boost { namespace mpl {
template< typename Tag > struct pop_back_impl;
template< typename Sequence > struct pop_back;
}}
#endif // BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED

83
3rdparty/boost/boost/mpl/remove_if.hpp vendored
View File

@ -1,83 +0,0 @@
#ifndef BOOST_MPL_REMOVE_IF_HPP_INCLUDED
#define BOOST_MPL_REMOVE_IF_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
// Copyright David Abrahams 2003-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/protect.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/aux_/inserter_algorithm.hpp>
namespace boost { namespace mpl {
namespace aux {
template< typename Pred, typename InsertOp > struct remove_if_helper
{
template< typename Sequence, typename U > struct apply
{
typedef typename eval_if<
typename apply1<Pred,U>::type
, identity<Sequence>
, apply2<InsertOp,Sequence,U>
>::type type;
};
};
template<
typename Sequence
, typename Predicate
, typename Inserter
>
struct remove_if_impl
: fold<
Sequence
, typename Inserter::state
, protect< aux::remove_if_helper<
typename lambda<Predicate>::type
, typename Inserter::operation
> >
>
{
};
template<
typename Sequence
, typename Predicate
, typename Inserter
>
struct reverse_remove_if_impl
: reverse_fold<
Sequence
, typename Inserter::state
, protect< aux::remove_if_helper<
typename lambda<Predicate>::type
, typename Inserter::operation
> >
>
{
};
} // namespace aux
BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, remove_if)
}}
#endif // BOOST_MPL_REMOVE_IF_HPP_INCLUDED

21
3rdparty/boost/boost/mpl/times.hpp vendored
View File

@ -1,21 +0,0 @@
#ifndef BOOST_MPL_TIMES_HPP_INCLUDED
#define BOOST_MPL_TIMES_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#define AUX778076_OP_NAME times
#define AUX778076_OP_TOKEN *
#include <boost/mpl/aux_/arithmetic_op.hpp>
#endif // BOOST_MPL_TIMES_HPP_INCLUDED

57
3rdparty/boost/boost/mpl/vector.hpp vendored
View File

@ -1,57 +0,0 @@
#ifndef BOOST_MPL_VECTOR_HPP_INCLUDED
#define BOOST_MPL_VECTOR_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/vector.hpp>
# include <boost/mpl/aux_/na.hpp>
# include <boost/mpl/aux_/config/preprocessor.hpp>
# include <boost/preprocessor/inc.hpp>
# include <boost/preprocessor/cat.hpp>
# include <boost/preprocessor/stringize.hpp>
#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING)
# define AUX778076_VECTOR_HEADER \
BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE).hpp \
/**/
#else
# define AUX778076_VECTOR_HEADER \
BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE)##.hpp \
/**/
#endif
# include BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_HEADER)
# undef AUX778076_VECTOR_HEADER
#endif
#include <boost/mpl/aux_/config/use_preprocessed.hpp>
#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE)
# define BOOST_MPL_PREPROCESSED_HEADER vector.hpp
# include <boost/mpl/aux_/include_preprocessed.hpp>
#else
# include <boost/mpl/limits/vector.hpp>
# define AUX778076_SEQUENCE_NAME vector
# define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE
# include <boost/mpl/aux_/sequence_wrapper.hpp>
#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
#endif // BOOST_MPL_VECTOR_HPP_INCLUDED

56
3rdparty/boost/boost/mpl/vector/aux_/O1_size.hpp vendored
View File

@ -1,56 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost { namespace mpl {
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
template<>
struct O1_size_impl< aux::vector_tag >
{
template< typename Vector > struct apply
: Vector::size
{
};
};
#else
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< long N >
struct O1_size_impl< aux::vector_tag<N> >
{
template< typename Vector > struct apply
: mpl::long_<N>
{
};
};
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
}}
#endif // BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED

116
3rdparty/boost/boost/mpl/vector/aux_/at.hpp vendored
View File

@ -1,116 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
#include <boost/mpl/aux_/type_wrapper.hpp>
#include <boost/mpl/aux_/value_wknd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost { namespace mpl {
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
template< typename Vector, long n_ >
struct v_at_impl
{
typedef long_< (Vector::lower_bound_::value + n_) > index_;
typedef __typeof__( Vector::item_(index_()) ) type;
};
template< typename Vector, long n_ >
struct v_at
: aux::wrapped_type< typename v_at_impl<Vector,n_>::type >
{
};
template<>
struct at_impl< aux::vector_tag >
{
template< typename Vector, typename N > struct apply
: v_at<
Vector
, BOOST_MPL_AUX_VALUE_WKND(N)::value
>
{
};
};
#else
# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC)
template< typename Vector, BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_at;
template< BOOST_MPL_AUX_NTTP_DECL(long, n_) >
struct at_impl< aux::vector_tag<n_> >
{
template< typename Vector, typename N > struct apply
#if !defined(__BORLANDC__)
: v_at<
Vector
, BOOST_MPL_AUX_VALUE_WKND(N)::value
>
{
#else
{
typedef typename v_at<
Vector
, BOOST_MPL_AUX_VALUE_WKND(N)::value
>::type type;
#endif
};
};
# else
namespace aux {
template< BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_at_impl
{
template< typename V > struct result_;
};
// to work around ETI, etc.
template<> struct v_at_impl<-1>
{
template< typename V > struct result_
{
typedef void_ type;
};
};
} // namespace aux
template< typename T, BOOST_MPL_AUX_NTTP_DECL(long, n_) >
struct v_at
: aux::v_at_impl<n_>::template result_<T>
{
};
# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
}}
#endif // BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED

59
3rdparty/boost/boost/mpl/vector/aux_/back.hpp vendored
View File

@ -1,59 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/back_fwd.hpp>
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/vector/aux_/at.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost { namespace mpl {
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
template<>
struct back_impl< aux::vector_tag >
{
template< typename Vector > struct apply
: v_at<
Vector
, prior<typename Vector::size>::type::value
>
{
};
};
#else
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< long n_ >
struct back_impl< aux::vector_tag<n_> >
{
template< typename Vector > struct apply
{
typedef typename Vector::back type;
};
};
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
}}
#endif // BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED

49
3rdparty/boost/boost/mpl/vector/aux_/begin_end.hpp vendored
View File

@ -1,49 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/aux_/config/typeof.hpp>
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
# include <boost/mpl/begin_end_fwd.hpp>
# include <boost/mpl/vector/aux_/iterator.hpp>
# include <boost/mpl/vector/aux_/tag.hpp>
namespace boost { namespace mpl {
template<>
struct begin_impl< aux::vector_tag >
{
template< typename Vector > struct apply
{
typedef v_iter<Vector,0> type;
};
};
template<>
struct end_impl< aux::vector_tag >
{
template< typename Vector > struct apply
{
typedef v_iter<Vector,Vector::size::value> type;
};
};
}}
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
#endif // BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED

55
3rdparty/boost/boost/mpl/vector/aux_/clear.hpp vendored
View File

@ -1,55 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/vector/aux_/vector0.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost { namespace mpl {
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
template<>
struct clear_impl< aux::vector_tag >
{
template< typename Vector > struct apply
{
typedef vector0<> type;
};
};
#else
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< long N >
struct clear_impl< aux::vector_tag<N> >
{
template< typename Vector > struct apply
{
typedef vector0<> type;
};
};
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
}}
#endif // BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED

68
3rdparty/boost/boost/mpl/vector/aux_/empty.hpp vendored
View File

@ -1,68 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace mpl {
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
template<>
struct empty_impl< aux::vector_tag >
{
template< typename Vector > struct apply
: is_same<
typename Vector::lower_bound_
, typename Vector::upper_bound_
>
{
};
};
#else
template<>
struct empty_impl< aux::vector_tag<0> >
{
template< typename Vector > struct apply
: true_
{
};
};
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< long N >
struct empty_impl< aux::vector_tag<N> >
{
template< typename Vector > struct apply
: false_
{
};
};
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
}}
#endif // BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED

56
3rdparty/boost/boost/mpl/vector/aux_/front.hpp vendored
View File

@ -1,56 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_FRONT_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_FRONT_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2008
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/vector/aux_/at.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost { namespace mpl {
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
template<>
struct front_impl< aux::vector_tag >
{
template< typename Vector > struct apply
: v_at<Vector,0>
{
};
};
#else
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< BOOST_MPL_AUX_NTTP_DECL(long, n_) >
struct front_impl< aux::vector_tag<n_> >
{
template< typename Vector > struct apply
{
typedef typename Vector::item0 type;
};
};
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
}}
#endif // BOOST_MPL_VECTOR_AUX_FRONT_HPP_INCLUDED

55
3rdparty/boost/boost/mpl/vector/aux_/include_preprocessed.hpp vendored
View File

@ -1,55 +0,0 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
// Copyright Aleksey Gurtovoy 2000-2006
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
#include <boost/mpl/aux_/config/preprocessor.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/stringize.hpp>
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
# define AUX778076_INCLUDE_DIR typeof_based
#elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|| defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC)
# define AUX778076_INCLUDE_DIR no_ctps
#else
# define AUX778076_INCLUDE_DIR plain
#endif
#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING)
# define AUX778076_HEADER \
AUX778076_INCLUDE_DIR/BOOST_MPL_PREPROCESSED_HEADER \
/**/
#else
# define AUX778076_HEADER \
BOOST_PP_CAT(AUX778076_INCLUDE_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \
/**/
#endif
#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(700))
# define AUX778076_INCLUDE_STRING BOOST_PP_STRINGIZE(boost/mpl/vector/aux_/preprocessed/AUX778076_HEADER)
# include AUX778076_INCLUDE_STRING
# undef AUX778076_INCLUDE_STRING
#else
# include BOOST_PP_STRINGIZE(boost/mpl/vector/aux_/preprocessed/AUX778076_HEADER)
#endif
# undef AUX778076_HEADER
# undef AUX778076_INCLUDE_DIR
#undef BOOST_MPL_PREPROCESSED_HEADER

103
3rdparty/boost/boost/mpl/vector/aux_/item.hpp vendored
View File

@ -1,103 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/aux_/type_wrapper.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost { namespace mpl {
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
template<
typename T
, typename Base
, int at_front = 0
>
struct v_item
: Base
{
typedef typename Base::upper_bound_ index_;
typedef typename next<index_>::type upper_bound_;
typedef typename next<typename Base::size>::type size;
typedef Base base;
typedef v_item type;
// agurt 10/sep/04: MWCW <= 9.3 workaround here and below; the compiler
// breaks if using declaration comes _before_ the new overload
static aux::type_wrapper<T> item_(index_);
using Base::item_;
};
template<
typename T
, typename Base
>
struct v_item<T,Base,1>
: Base
{
typedef typename prior<typename Base::lower_bound_>::type index_;
typedef index_ lower_bound_;
typedef typename next<typename Base::size>::type size;
typedef Base base;
typedef v_item type;
static aux::type_wrapper<T> item_(index_);
using Base::item_;
};
// "erasure" item
template<
typename Base
, int at_front
>
struct v_mask
: Base
{
typedef typename prior<typename Base::upper_bound_>::type index_;
typedef index_ upper_bound_;
typedef typename prior<typename Base::size>::type size;
typedef Base base;
typedef v_mask type;
static aux::type_wrapper<void_> item_(index_);
using Base::item_;
};
template<
typename Base
>
struct v_mask<Base,1>
: Base
{
typedef typename Base::lower_bound_ index_;
typedef typename next<index_>::type lower_bound_;
typedef typename prior<typename Base::size>::type size;
typedef Base base;
typedef v_mask type;
static aux::type_wrapper<void_> item_(index_);
using Base::item_;
};
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
}}
#endif // BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED

130
3rdparty/boost/boost/mpl/vector/aux_/iterator.hpp vendored
View File

@ -1,130 +0,0 @@
#ifndef BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED
#define BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/vector/aux_/at.hpp>
#include <boost/mpl/iterator_tags.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/advance_fwd.hpp>
#include <boost/mpl/distance_fwd.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/prior.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
#include <boost/mpl/aux_/value_wknd.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
namespace boost { namespace mpl {
template<
typename Vector
, BOOST_MPL_AUX_NTTP_DECL(long, n_)
>
struct v_iter
{
typedef aux::v_iter_tag tag;
typedef random_access_iterator_tag category;
typedef typename v_at<Vector,n_>::type type;
typedef Vector vector_;
typedef mpl::long_<n_> pos;
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
enum {
next_ = n_ + 1
, prior_ = n_ - 1
, pos_ = n_
};
typedef v_iter<Vector,next_> next;
typedef v_iter<Vector,prior_> prior;
#endif
};
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template<
typename Vector
, BOOST_MPL_AUX_NTTP_DECL(long, n_)
>
struct next< v_iter<Vector,n_> >
{
typedef v_iter<Vector,(n_ + 1)> type;
};
template<
typename Vector
, BOOST_MPL_AUX_NTTP_DECL(long, n_)
>
struct prior< v_iter<Vector,n_> >
{
typedef v_iter<Vector,(n_ - 1)> type;
};
template<
typename Vector
, BOOST_MPL_AUX_NTTP_DECL(long, n_)
, typename Distance
>
struct advance< v_iter<Vector,n_>,Distance>
{
typedef v_iter<
Vector
, (n_ + BOOST_MPL_AUX_NESTED_VALUE_WKND(long, Distance))
> type;
};
template<
typename Vector
, BOOST_MPL_AUX_NTTP_DECL(long, n_)
, BOOST_MPL_AUX_NTTP_DECL(long, m_)
>
struct distance< v_iter<Vector,n_>, v_iter<Vector,m_> >
: mpl::long_<(m_ - n_)>
{
};
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<> struct advance_impl<aux::v_iter_tag>
{
template< typename Iterator, typename N > struct apply
{
enum { pos_ = Iterator::pos_, n_ = N::value };
typedef v_iter<
typename Iterator::vector_
, (pos_ + n_)
> type;
};
};
template<> struct distance_impl<aux::v_iter_tag>
{
template< typename Iter1, typename Iter2 > struct apply
{
enum { pos1_ = Iter1::pos_, pos2_ = Iter2::pos_ };
typedef long_<( pos2_ - pos1_ )> type;
BOOST_STATIC_CONSTANT(long, value = ( pos2_ - pos1_ ));
};
};
#endif
}}
#endif // BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED

218
3rdparty/boost/boost/mpl/vector/aux_/numbered.hpp vendored
View File

@ -1,218 +0,0 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
#if defined(BOOST_PP_IS_ITERATING)
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/enum_shifted_params.hpp>
#include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/dec.hpp>
#include <boost/preprocessor/cat.hpp>
#define i_ BOOST_PP_FRAME_ITERATION(1)
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
# define AUX778076_VECTOR_TAIL(vector, i_, T) \
BOOST_PP_CAT(vector,i_)< \
BOOST_PP_ENUM_PARAMS(i_, T) \
> \
/**/
#if i_ > 0
template<
BOOST_PP_ENUM_PARAMS(i_, typename T)
>
struct BOOST_PP_CAT(vector,i_)
: v_item<
BOOST_PP_CAT(T,BOOST_PP_DEC(i_))
, AUX778076_VECTOR_TAIL(vector,BOOST_PP_DEC(i_),T)
>
{
typedef BOOST_PP_CAT(vector,i_) type;
};
#endif
# undef AUX778076_VECTOR_TAIL
#else // "brute force" implementation
# if i_ > 0
template<
BOOST_PP_ENUM_PARAMS(i_, typename T)
>
struct BOOST_PP_CAT(vector,i_)
{
typedef aux::vector_tag<i_> tag;
typedef BOOST_PP_CAT(vector,i_) type;
# define AUX778076_VECTOR_ITEM(unused, i_, unused2) \
typedef BOOST_PP_CAT(T,i_) BOOST_PP_CAT(item,i_); \
/**/
BOOST_PP_REPEAT(i_, AUX778076_VECTOR_ITEM, unused)
# undef AUX778076_VECTOR_ITEM
typedef void_ BOOST_PP_CAT(item,i_);
typedef BOOST_PP_CAT(T,BOOST_PP_DEC(i_)) back;
// Borland forces us to use 'type' here (instead of the class name)
typedef v_iter<type,0> begin;
typedef v_iter<type,i_> end;
};
template<>
struct push_front_impl< aux::vector_tag<BOOST_PP_DEC(i_)> >
{
template< typename Vector, typename T > struct apply
{
typedef BOOST_PP_CAT(vector,i_)<
T
BOOST_PP_COMMA_IF(BOOST_PP_DEC(i_))
BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item)
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<i_> >
{
template< typename Vector > struct apply
{
typedef BOOST_PP_CAT(vector,BOOST_PP_DEC(i_))<
BOOST_PP_ENUM_SHIFTED_PARAMS(i_, typename Vector::item)
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<BOOST_PP_DEC(i_)> >
{
template< typename Vector, typename T > struct apply
{
typedef BOOST_PP_CAT(vector,i_)<
BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item)
BOOST_PP_COMMA_IF(BOOST_PP_DEC(i_))
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<i_> >
{
template< typename Vector > struct apply
{
typedef BOOST_PP_CAT(vector,BOOST_PP_DEC(i_))<
BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item)
> type;
};
};
# endif // i_ > 0
# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC)
template< typename V >
struct v_at<V,i_>
{
typedef typename V::BOOST_PP_CAT(item,i_) type;
};
# else
namespace aux {
template<> struct v_at_impl<i_>
{
template< typename V_ > struct result_
{
typedef typename V_::BOOST_PP_CAT(item,i_) type;
};
};
}
template<>
struct at_impl< aux::vector_tag<i_> >
{
template< typename V_, typename N > struct apply
{
typedef typename aux::v_at_impl<BOOST_MPL_AUX_VALUE_WKND(N)::value>
::template result_<V_>::type type;
};
};
#if i_ > 0
template<>
struct front_impl< aux::vector_tag<i_> >
{
template< typename Vector > struct apply
{
typedef typename Vector::item0 type;
};
};
template<>
struct back_impl< aux::vector_tag<i_> >
{
template< typename Vector > struct apply
{
typedef typename Vector::back type;
};
};
template<>
struct empty_impl< aux::vector_tag<i_> >
{
template< typename Vector > struct apply
: false_
{
};
};
#endif
template<>
struct size_impl< aux::vector_tag<i_> >
{
template< typename Vector > struct apply
: long_<i_>
{
};
};
template<>
struct O1_size_impl< aux::vector_tag<i_> >
: size_impl< aux::vector_tag<i_> >
{
};
template<>
struct clear_impl< aux::vector_tag<i_> >
{
template< typename Vector > struct apply
{
typedef vector0<> type;
};
};
# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
#undef i_
#endif // BOOST_PP_IS_ITERATING

77
3rdparty/boost/boost/mpl/vector/aux_/numbered_c.hpp vendored
View File

@ -1,77 +0,0 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
#if defined(BOOST_PP_IS_ITERATING)
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/enum_shifted_params.hpp>
#include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/dec.hpp>
#include <boost/preprocessor/cat.hpp>
#define i_ BOOST_PP_FRAME_ITERATION(1)
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
# define AUX778076_VECTOR_TAIL(vector, i_, C) \
BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c)<T \
BOOST_PP_COMMA_IF(i_) BOOST_PP_ENUM_PARAMS(i_, C) \
> \
/**/
#if i_ > 0
template<
typename T
, BOOST_PP_ENUM_PARAMS(i_, T C)
>
struct BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c)
: v_item<
integral_c<T,BOOST_PP_CAT(C,BOOST_PP_DEC(i_))>
, AUX778076_VECTOR_TAIL(vector,BOOST_PP_DEC(i_),C)
>
{
typedef BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) type;
typedef T value_type;
};
#endif
# undef AUX778076_VECTOR_TAIL
#else // "brute force" implementation
# define AUX778076_VECTOR_C_PARAM_FUNC(unused, i_, param) \
BOOST_PP_COMMA_IF(i_) \
integral_c<T,BOOST_PP_CAT(param,i_)> \
/**/
template<
typename T
, BOOST_PP_ENUM_PARAMS(i_, T C)
>
struct BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c)
: BOOST_PP_CAT(vector,i_)< BOOST_PP_REPEAT(i_,AUX778076_VECTOR_C_PARAM_FUNC,C) >
{
typedef BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) type;
typedef T value_type;
};
# undef AUX778076_VECTOR_C_PARAM_FUNC
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
#undef i_
#endif // BOOST_PP_IS_ITERATING

40
3rdparty/boost/boost/mpl/vector/aux_/pop_back.hpp vendored
View File

@ -1,40 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/pop_back_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
# include <boost/mpl/vector/aux_/item.hpp>
# include <boost/mpl/vector/aux_/tag.hpp>
namespace boost { namespace mpl {
template<>
struct pop_back_impl< aux::vector_tag >
{
template< typename Vector > struct apply
{
typedef v_mask<Vector,0> type;
};
};
}}
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
#endif // BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED

40
3rdparty/boost/boost/mpl/vector/aux_/pop_front.hpp vendored
View File

@ -1,40 +0,0 @@
#ifndef BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED
#define BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/pop_front_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
# include <boost/mpl/vector/aux_/item.hpp>
# include <boost/mpl/vector/aux_/tag.hpp>
namespace boost { namespace mpl {
template<>
struct pop_front_impl< aux::vector_tag >
{
template< typename Vector > struct apply
{
typedef v_mask<Vector,1> type;
};
};
}}
#endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
#endif // BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED

1528
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp vendored
View File

File diff suppressed because it is too large Load Diff

149
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp vendored
View File

@ -1,149 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0
>
struct vector1_c
: vector1< integral_c< T,C0 > >
{
typedef vector1_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1
>
struct vector2_c
: vector2< integral_c< T,C0 >, integral_c< T,C1 > >
{
typedef vector2_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2
>
struct vector3_c
: vector3< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > >
{
typedef vector3_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3
>
struct vector4_c
: vector4<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >, integral_c<T
, C3>
>
{
typedef vector4_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4
>
struct vector5_c
: vector5<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >
>
{
typedef vector5_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5
>
struct vector6_c
: vector6<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >
>
{
typedef vector6_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6
>
struct vector7_c
: vector7<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c<T
, C6>
>
{
typedef vector7_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7
>
struct vector8_c
: vector8<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >
>
{
typedef vector8_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8
>
struct vector9_c
: vector9<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >
>
{
typedef vector9_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9
>
struct vector10_c
: vector10<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
>
{
typedef vector10_c type;
typedef T value_type;
};
}}

1804
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp vendored
View File

File diff suppressed because it is too large Load Diff

195
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp vendored
View File

@ -1,195 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
>
struct vector11_c
: vector11<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >, integral_c<T
, C10>
>
{
typedef vector11_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11
>
struct vector12_c
: vector12<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >
>
{
typedef vector12_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12
>
struct vector13_c
: vector13<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
>
{
typedef vector13_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13
>
struct vector14_c
: vector14<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >, integral_c<T
, C13>
>
{
typedef vector14_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14
>
struct vector15_c
: vector15<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >
>
{
typedef vector15_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15
>
struct vector16_c
: vector16<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
>
{
typedef vector16_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16
>
struct vector17_c
: vector17<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >, integral_c<T
, C16>
>
{
typedef vector17_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17
>
struct vector18_c
: vector18<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >
>
{
typedef vector18_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18
>
struct vector19_c
: vector19<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
>
{
typedef vector19_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19
>
struct vector20_c
: vector20<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >, integral_c<T
, C19>
>
{
typedef vector20_c type;
typedef T value_type;
};
}}

2124
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp vendored
View File

File diff suppressed because it is too large Load Diff

238
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp vendored
View File

@ -1,238 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
>
struct vector21_c
: vector21<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >
>
{
typedef vector21_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21
>
struct vector22_c
: vector22<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
>
{
typedef vector22_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22
>
struct vector23_c
: vector23<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >, integral_c<T
, C22>
>
{
typedef vector23_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23
>
struct vector24_c
: vector24<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >
>
{
typedef vector24_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24
>
struct vector25_c
: vector25<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
>
{
typedef vector25_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25
>
struct vector26_c
: vector26<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >, integral_c<T
, C25>
>
{
typedef vector26_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26
>
struct vector27_c
: vector27<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >
>
{
typedef vector27_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27
>
struct vector28_c
: vector28<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
>
{
typedef vector28_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28
>
struct vector29_c
: vector29<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >, integral_c<T
, C28>
>
{
typedef vector29_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29
>
struct vector30_c
: vector30<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >
>
{
typedef vector30_c type;
typedef T value_type;
};
}}

2444
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp vendored
View File

File diff suppressed because it is too large Load Diff

281
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp vendored
View File

@ -1,281 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
>
struct vector31_c
: vector31<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
>
{
typedef vector31_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31
>
struct vector32_c
: vector32<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >, integral_c<T
, C31>
>
{
typedef vector32_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32
>
struct vector33_c
: vector33<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >
>
{
typedef vector33_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33
>
struct vector34_c
: vector34<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
>
{
typedef vector34_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34
>
struct vector35_c
: vector35<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >, integral_c<T
, C34>
>
{
typedef vector35_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35
>
struct vector36_c
: vector36<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >
>
{
typedef vector36_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36
>
struct vector37_c
: vector37<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
>
{
typedef vector37_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37
>
struct vector38_c
: vector38<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >, integral_c<T
, C37>
>
{
typedef vector38_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38
>
struct vector39_c
: vector39<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >
>
{
typedef vector39_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39
>
struct vector40_c
: vector40<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
>
{
typedef vector40_c type;
typedef T value_type;
};
}}

2764
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp vendored
View File

File diff suppressed because it is too large Load Diff

325
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp vendored
View File

@ -1,325 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
>
struct vector41_c
: vector41<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >, integral_c<T
, C40>
>
{
typedef vector41_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41
>
struct vector42_c
: vector42<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >
>
{
typedef vector42_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42
>
struct vector43_c
: vector43<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
>
{
typedef vector43_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43
>
struct vector44_c
: vector44<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >, integral_c<T
, C43>
>
{
typedef vector44_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44
>
struct vector45_c
: vector45<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >
>
{
typedef vector45_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45
>
struct vector46_c
: vector46<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
>
{
typedef vector46_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46
>
struct vector47_c
: vector47<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >, integral_c<T
, C46>
>
{
typedef vector47_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46, T C47
>
struct vector48_c
: vector48<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
, integral_c< T,C46 >, integral_c< T,C47 >
>
{
typedef vector48_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48
>
struct vector49_c
: vector49<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
, integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >
>
{
typedef vector49_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49
>
struct vector50_c
: vector50<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
, integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >, integral_c<T
, C49>
>
{
typedef vector50_c type;
typedef T value_type;
};
}}

829
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp vendored
View File

@ -1,829 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector10.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template< typename V >
struct v_at< V,0 >
{
typedef typename V::item0 type;
};
template<
typename T0
>
struct vector1
{
typedef aux::vector_tag<1> tag;
typedef vector1 type;
typedef T0 item0;
typedef void_ item1;
typedef T0 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,1 > end;
};
template<>
struct push_front_impl< aux::vector_tag<0> >
{
template< typename Vector, typename T > struct apply
{
typedef vector1<
T
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<1> >
{
template< typename Vector > struct apply
{
typedef vector0<
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<0> >
{
template< typename Vector, typename T > struct apply
{
typedef vector1<
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<1> >
{
template< typename Vector > struct apply
{
typedef vector0<
> type;
};
};
template< typename V >
struct v_at< V,1 >
{
typedef typename V::item1 type;
};
template<
typename T0, typename T1
>
struct vector2
{
typedef aux::vector_tag<2> tag;
typedef vector2 type;
typedef T0 item0;
typedef T1 item1;
typedef void_ item2;
typedef T1 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,2 > end;
};
template<>
struct push_front_impl< aux::vector_tag<1> >
{
template< typename Vector, typename T > struct apply
{
typedef vector2<
T
,
typename Vector::item0
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<2> >
{
template< typename Vector > struct apply
{
typedef vector1<
typename Vector::item1
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<1> >
{
template< typename Vector, typename T > struct apply
{
typedef vector2<
typename Vector::item0
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<2> >
{
template< typename Vector > struct apply
{
typedef vector1<
typename Vector::item0
> type;
};
};
template< typename V >
struct v_at< V,2 >
{
typedef typename V::item2 type;
};
template<
typename T0, typename T1, typename T2
>
struct vector3
{
typedef aux::vector_tag<3> tag;
typedef vector3 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef void_ item3;
typedef T2 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,3 > end;
};
template<>
struct push_front_impl< aux::vector_tag<2> >
{
template< typename Vector, typename T > struct apply
{
typedef vector3<
T
,
typename Vector::item0, typename Vector::item1
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<3> >
{
template< typename Vector > struct apply
{
typedef vector2<
typename Vector::item1, typename Vector::item2
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<2> >
{
template< typename Vector, typename T > struct apply
{
typedef vector3<
typename Vector::item0, typename Vector::item1
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<3> >
{
template< typename Vector > struct apply
{
typedef vector2<
typename Vector::item0, typename Vector::item1
> type;
};
};
template< typename V >
struct v_at< V,3 >
{
typedef typename V::item3 type;
};
template<
typename T0, typename T1, typename T2, typename T3
>
struct vector4
{
typedef aux::vector_tag<4> tag;
typedef vector4 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef T3 item3;
typedef void_ item4;
typedef T3 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,4 > end;
};
template<>
struct push_front_impl< aux::vector_tag<3> >
{
template< typename Vector, typename T > struct apply
{
typedef vector4<
T
,
typename Vector::item0, typename Vector::item1
, typename Vector::item2
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<4> >
{
template< typename Vector > struct apply
{
typedef vector3<
typename Vector::item1, typename Vector::item2
, typename Vector::item3
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<3> >
{
template< typename Vector, typename T > struct apply
{
typedef vector4<
typename Vector::item0, typename Vector::item1
, typename Vector::item2
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<4> >
{
template< typename Vector > struct apply
{
typedef vector3<
typename Vector::item0, typename Vector::item1
, typename Vector::item2
> type;
};
};
template< typename V >
struct v_at< V,4 >
{
typedef typename V::item4 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
>
struct vector5
{
typedef aux::vector_tag<5> tag;
typedef vector5 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef T3 item3;
typedef T4 item4;
typedef void_ item5;
typedef T4 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,5 > end;
};
template<>
struct push_front_impl< aux::vector_tag<4> >
{
template< typename Vector, typename T > struct apply
{
typedef vector5<
T
,
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<5> >
{
template< typename Vector > struct apply
{
typedef vector4<
typename Vector::item1, typename Vector::item2
, typename Vector::item3, typename Vector::item4
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<4> >
{
template< typename Vector, typename T > struct apply
{
typedef vector5<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<5> >
{
template< typename Vector > struct apply
{
typedef vector4<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
> type;
};
};
template< typename V >
struct v_at< V,5 >
{
typedef typename V::item5 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5
>
struct vector6
{
typedef aux::vector_tag<6> tag;
typedef vector6 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef T3 item3;
typedef T4 item4;
typedef T5 item5;
typedef void_ item6;
typedef T5 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,6 > end;
};
template<>
struct push_front_impl< aux::vector_tag<5> >
{
template< typename Vector, typename T > struct apply
{
typedef vector6<
T
,
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<6> >
{
template< typename Vector > struct apply
{
typedef vector5<
typename Vector::item1, typename Vector::item2
, typename Vector::item3, typename Vector::item4
, typename Vector::item5
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<5> >
{
template< typename Vector, typename T > struct apply
{
typedef vector6<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<6> >
{
template< typename Vector > struct apply
{
typedef vector5<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4
> type;
};
};
template< typename V >
struct v_at< V,6 >
{
typedef typename V::item6 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6
>
struct vector7
{
typedef aux::vector_tag<7> tag;
typedef vector7 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef T3 item3;
typedef T4 item4;
typedef T5 item5;
typedef T6 item6;
typedef void_ item7;
typedef T6 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,7 > end;
};
template<>
struct push_front_impl< aux::vector_tag<6> >
{
template< typename Vector, typename T > struct apply
{
typedef vector7<
T
,
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<7> >
{
template< typename Vector > struct apply
{
typedef vector6<
typename Vector::item1, typename Vector::item2
, typename Vector::item3, typename Vector::item4
, typename Vector::item5, typename Vector::item6
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<6> >
{
template< typename Vector, typename T > struct apply
{
typedef vector7<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<7> >
{
template< typename Vector > struct apply
{
typedef vector6<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
> type;
};
};
template< typename V >
struct v_at< V,7 >
{
typedef typename V::item7 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7
>
struct vector8
{
typedef aux::vector_tag<8> tag;
typedef vector8 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef T3 item3;
typedef T4 item4;
typedef T5 item5;
typedef T6 item6;
typedef T7 item7;
typedef void_ item8;
typedef T7 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,8 > end;
};
template<>
struct push_front_impl< aux::vector_tag<7> >
{
template< typename Vector, typename T > struct apply
{
typedef vector8<
T
,
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<8> >
{
template< typename Vector > struct apply
{
typedef vector7<
typename Vector::item1, typename Vector::item2
, typename Vector::item3, typename Vector::item4
, typename Vector::item5, typename Vector::item6
, typename Vector::item7
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<7> >
{
template< typename Vector, typename T > struct apply
{
typedef vector8<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<8> >
{
template< typename Vector > struct apply
{
typedef vector7<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6
> type;
};
};
template< typename V >
struct v_at< V,8 >
{
typedef typename V::item8 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8
>
struct vector9
{
typedef aux::vector_tag<9> tag;
typedef vector9 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef T3 item3;
typedef T4 item4;
typedef T5 item5;
typedef T6 item6;
typedef T7 item7;
typedef T8 item8;
typedef void_ item9;
typedef T8 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,9 > end;
};
template<>
struct push_front_impl< aux::vector_tag<8> >
{
template< typename Vector, typename T > struct apply
{
typedef vector9<
T
,
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6, typename Vector::item7
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<9> >
{
template< typename Vector > struct apply
{
typedef vector8<
typename Vector::item1, typename Vector::item2
, typename Vector::item3, typename Vector::item4
, typename Vector::item5, typename Vector::item6
, typename Vector::item7, typename Vector::item8
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<8> >
{
template< typename Vector, typename T > struct apply
{
typedef vector9<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6, typename Vector::item7
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<9> >
{
template< typename Vector > struct apply
{
typedef vector8<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6, typename Vector::item7
> type;
};
};
template< typename V >
struct v_at< V,9 >
{
typedef typename V::item9 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
>
struct vector10
{
typedef aux::vector_tag<10> tag;
typedef vector10 type;
typedef T0 item0;
typedef T1 item1;
typedef T2 item2;
typedef T3 item3;
typedef T4 item4;
typedef T5 item5;
typedef T6 item6;
typedef T7 item7;
typedef T8 item8;
typedef T9 item9;
typedef void_ item10;
typedef T9 back;
typedef v_iter< type,0 > begin;
typedef v_iter< type,10 > end;
};
template<>
struct push_front_impl< aux::vector_tag<9> >
{
template< typename Vector, typename T > struct apply
{
typedef vector10<
T
,
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6, typename Vector::item7
, typename Vector::item8
> type;
};
};
template<>
struct pop_front_impl< aux::vector_tag<10> >
{
template< typename Vector > struct apply
{
typedef vector9<
typename Vector::item1, typename Vector::item2
, typename Vector::item3, typename Vector::item4
, typename Vector::item5, typename Vector::item6
, typename Vector::item7, typename Vector::item8
, typename Vector::item9
> type;
};
};
template<>
struct push_back_impl< aux::vector_tag<9> >
{
template< typename Vector, typename T > struct apply
{
typedef vector10<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6, typename Vector::item7
, typename Vector::item8
,
T
> type;
};
};
template<>
struct pop_back_impl< aux::vector_tag<10> >
{
template< typename Vector > struct apply
{
typedef vector9<
typename Vector::item0, typename Vector::item1
, typename Vector::item2, typename Vector::item3
, typename Vector::item4, typename Vector::item5
, typename Vector::item6, typename Vector::item7
, typename Vector::item8
> type;
};
};
template< typename V >
struct v_at< V,10 >
{
typedef typename V::item10 type;
};
}}

149
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp vendored
View File

@ -1,149 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0
>
struct vector1_c
: vector1< integral_c< T,C0 > >
{
typedef vector1_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1
>
struct vector2_c
: vector2< integral_c< T,C0 >, integral_c< T,C1 > >
{
typedef vector2_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2
>
struct vector3_c
: vector3< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > >
{
typedef vector3_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3
>
struct vector4_c
: vector4<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >, integral_c<T
, C3>
>
{
typedef vector4_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4
>
struct vector5_c
: vector5<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >
>
{
typedef vector5_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5
>
struct vector6_c
: vector6<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >
>
{
typedef vector6_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6
>
struct vector7_c
: vector7<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c<T
, C6>
>
{
typedef vector7_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7
>
struct vector8_c
: vector8<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >
>
{
typedef vector8_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8
>
struct vector9_c
: vector9<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >
>
{
typedef vector9_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9
>
struct vector10_c
: vector10<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
>
{
typedef vector10_c type;
typedef T value_type;
};
}}

1144
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp vendored
View File

File diff suppressed because it is too large Load Diff

195
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp vendored
View File

@ -1,195 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
>
struct vector11_c
: vector11<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >, integral_c<T
, C10>
>
{
typedef vector11_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11
>
struct vector12_c
: vector12<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >
>
{
typedef vector12_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12
>
struct vector13_c
: vector13<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
>
{
typedef vector13_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13
>
struct vector14_c
: vector14<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >, integral_c<T
, C13>
>
{
typedef vector14_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14
>
struct vector15_c
: vector15<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >
>
{
typedef vector15_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15
>
struct vector16_c
: vector16<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
>
{
typedef vector16_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16
>
struct vector17_c
: vector17<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >, integral_c<T
, C16>
>
{
typedef vector17_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17
>
struct vector18_c
: vector18<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >
>
{
typedef vector18_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18
>
struct vector19_c
: vector19<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
>
{
typedef vector19_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19
>
struct vector20_c
: vector20<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >, integral_c<T
, C19>
>
{
typedef vector20_c type;
typedef T value_type;
};
}}

1464
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp vendored
View File

File diff suppressed because it is too large Load Diff

238
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp vendored
View File

@ -1,238 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
>
struct vector21_c
: vector21<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >
>
{
typedef vector21_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21
>
struct vector22_c
: vector22<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
>
{
typedef vector22_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22
>
struct vector23_c
: vector23<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >, integral_c<T
, C22>
>
{
typedef vector23_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23
>
struct vector24_c
: vector24<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >
>
{
typedef vector24_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24
>
struct vector25_c
: vector25<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
>
{
typedef vector25_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25
>
struct vector26_c
: vector26<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >, integral_c<T
, C25>
>
{
typedef vector26_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26
>
struct vector27_c
: vector27<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >
>
{
typedef vector27_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27
>
struct vector28_c
: vector28<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
>
{
typedef vector28_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28
>
struct vector29_c
: vector29<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >, integral_c<T
, C28>
>
{
typedef vector29_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29
>
struct vector30_c
: vector30<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >
>
{
typedef vector30_c type;
typedef T value_type;
};
}}

1784
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp vendored
View File

File diff suppressed because it is too large Load Diff

281
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp vendored
View File

@ -1,281 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
>
struct vector31_c
: vector31<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
>
{
typedef vector31_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31
>
struct vector32_c
: vector32<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >, integral_c<T
, C31>
>
{
typedef vector32_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32
>
struct vector33_c
: vector33<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >
>
{
typedef vector33_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33
>
struct vector34_c
: vector34<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
>
{
typedef vector34_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34
>
struct vector35_c
: vector35<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >, integral_c<T
, C34>
>
{
typedef vector35_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35
>
struct vector36_c
: vector36<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >
>
{
typedef vector36_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36
>
struct vector37_c
: vector37<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
>
{
typedef vector37_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37
>
struct vector38_c
: vector38<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >, integral_c<T
, C37>
>
{
typedef vector38_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38
>
struct vector39_c
: vector39<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >
>
{
typedef vector39_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39
>
struct vector40_c
: vector40<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
>
{
typedef vector40_c type;
typedef T value_type;
};
}}

2104
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp vendored
View File

File diff suppressed because it is too large Load Diff

325
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp vendored
View File

@ -1,325 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
>
struct vector41_c
: vector41<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >, integral_c<T
, C40>
>
{
typedef vector41_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41
>
struct vector42_c
: vector42<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >
>
{
typedef vector42_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42
>
struct vector43_c
: vector43<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
>
{
typedef vector43_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43
>
struct vector44_c
: vector44<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >, integral_c<T
, C43>
>
{
typedef vector44_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44
>
struct vector45_c
: vector45<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >
>
{
typedef vector45_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45
>
struct vector46_c
: vector46<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
>
{
typedef vector46_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46
>
struct vector47_c
: vector47<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >, integral_c<T
, C46>
>
{
typedef vector47_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46, T C47
>
struct vector48_c
: vector48<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
, integral_c< T,C46 >, integral_c< T,C47 >
>
{
typedef vector48_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48
>
struct vector49_c
: vector49<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
, integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >
>
{
typedef vector49_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30
, T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40
, T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49
>
struct vector50_c
: vector50<
integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >
, integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 >
, integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >
, integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >
, integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >
, integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >
, integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >
, integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >
, integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >
, integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >
, integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >
, integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >
, integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >
, integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >
, integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >
, integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >, integral_c<T
, C49>
>
{
typedef vector50_c type;
typedef T value_type;
};
}}

139
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp vendored
View File

@ -1,139 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector10.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T0
>
struct vector1
: v_item<
T0
, vector0< >
>
{
typedef vector1 type;
};
template<
typename T0, typename T1
>
struct vector2
: v_item<
T1
, vector1<T0>
>
{
typedef vector2 type;
};
template<
typename T0, typename T1, typename T2
>
struct vector3
: v_item<
T2
, vector2< T0,T1 >
>
{
typedef vector3 type;
};
template<
typename T0, typename T1, typename T2, typename T3
>
struct vector4
: v_item<
T3
, vector3< T0,T1,T2 >
>
{
typedef vector4 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
>
struct vector5
: v_item<
T4
, vector4< T0,T1,T2,T3 >
>
{
typedef vector5 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5
>
struct vector6
: v_item<
T5
, vector5< T0,T1,T2,T3,T4 >
>
{
typedef vector6 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6
>
struct vector7
: v_item<
T6
, vector6< T0,T1,T2,T3,T4,T5 >
>
{
typedef vector7 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7
>
struct vector8
: v_item<
T7
, vector7< T0,T1,T2,T3,T4,T5,T6 >
>
{
typedef vector8 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8
>
struct vector9
: v_item<
T8
, vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
>
{
typedef vector9 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
>
struct vector10
: v_item<
T9
, vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
>
{
typedef vector10 type;
};
}}

154
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp vendored
View File

@ -1,154 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0
>
struct vector1_c
: v_item<
integral_c< T,C0 >
, vector0_c<T>
>
{
typedef vector1_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1
>
struct vector2_c
: v_item<
integral_c< T,C1 >
, vector1_c< T,C0 >
>
{
typedef vector2_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2
>
struct vector3_c
: v_item<
integral_c< T,C2 >
, vector2_c< T,C0,C1 >
>
{
typedef vector3_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3
>
struct vector4_c
: v_item<
integral_c< T,C3 >
, vector3_c< T,C0,C1,C2 >
>
{
typedef vector4_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4
>
struct vector5_c
: v_item<
integral_c< T,C4 >
, vector4_c< T,C0,C1,C2,C3 >
>
{
typedef vector5_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5
>
struct vector6_c
: v_item<
integral_c< T,C5 >
, vector5_c< T,C0,C1,C2,C3,C4 >
>
{
typedef vector6_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6
>
struct vector7_c
: v_item<
integral_c< T,C6 >
, vector6_c< T,C0,C1,C2,C3,C4,C5 >
>
{
typedef vector7_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7
>
struct vector8_c
: v_item<
integral_c< T,C7 >
, vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >
>
{
typedef vector8_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8
>
struct vector9_c
: v_item<
integral_c< T,C8 >
, vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >
>
{
typedef vector9_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9
>
struct vector10_c
: v_item<
integral_c< T,C9 >
, vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >
>
{
typedef vector10_c type;
typedef T value_type;
};
}}

159
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp vendored
View File

@ -1,159 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector20.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10
>
struct vector11
: v_item<
T10
, vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
>
{
typedef vector11 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11
>
struct vector12
: v_item<
T11
, vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
>
{
typedef vector12 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12
>
struct vector13
: v_item<
T12
, vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
>
{
typedef vector13 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13
>
struct vector14
: v_item<
T13
, vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
>
{
typedef vector14 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
>
struct vector15
: v_item<
T14
, vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
>
{
typedef vector15 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15
>
struct vector16
: v_item<
T15
, vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
>
{
typedef vector16 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16
>
struct vector17
: v_item<
T16
, vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
>
{
typedef vector17 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17
>
struct vector18
: v_item<
T17
, vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
>
{
typedef vector18 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18
>
struct vector19
: v_item<
T18
, vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
>
{
typedef vector19 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
>
struct vector20
: v_item<
T19
, vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
>
{
typedef vector20 type;
};
}}

163
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp vendored
View File

@ -1,163 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
>
struct vector11_c
: v_item<
integral_c< T,C10 >
, vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >
>
{
typedef vector11_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11
>
struct vector12_c
: v_item<
integral_c< T,C11 >
, vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >
>
{
typedef vector12_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12
>
struct vector13_c
: v_item<
integral_c< T,C12 >
, vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >
>
{
typedef vector13_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13
>
struct vector14_c
: v_item<
integral_c< T,C13 >
, vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >
>
{
typedef vector14_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14
>
struct vector15_c
: v_item<
integral_c< T,C14 >
, vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >
>
{
typedef vector15_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15
>
struct vector16_c
: v_item<
integral_c< T,C15 >
, vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >
>
{
typedef vector16_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16
>
struct vector17_c
: v_item<
integral_c< T,C16 >
, vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >
>
{
typedef vector17_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17
>
struct vector18_c
: v_item<
integral_c< T,C17 >
, vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >
>
{
typedef vector18_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18
>
struct vector19_c
: v_item<
integral_c< T,C18 >
, vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >
>
{
typedef vector19_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19
>
struct vector20_c
: v_item<
integral_c< T,C19 >
, vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >
>
{
typedef vector20_c type;
typedef T value_type;
};
}}

179
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp vendored
View File

@ -1,179 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector30.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20
>
struct vector21
: v_item<
T20
, vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >
>
{
typedef vector21 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21
>
struct vector22
: v_item<
T21
, vector21< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 >
>
{
typedef vector22 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22
>
struct vector23
: v_item<
T22
, vector22< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 >
>
{
typedef vector23 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22, typename T23
>
struct vector24
: v_item<
T23
, vector23< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 >
>
{
typedef vector24 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22, typename T23, typename T24
>
struct vector25
: v_item<
T24
, vector24< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 >
>
{
typedef vector25 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22, typename T23, typename T24
, typename T25
>
struct vector26
: v_item<
T25
, vector25< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 >
>
{
typedef vector26 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22, typename T23, typename T24
, typename T25, typename T26
>
struct vector27
: v_item<
T26
, vector26< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 >
>
{
typedef vector27 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22, typename T23, typename T24
, typename T25, typename T26, typename T27
>
struct vector28
: v_item<
T27
, vector27< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 >
>
{
typedef vector28 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22, typename T23, typename T24
, typename T25, typename T26, typename T27, typename T28
>
struct vector29
: v_item<
T28
, vector28< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 >
>
{
typedef vector29 type;
};
template<
typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9
, typename T10, typename T11, typename T12, typename T13, typename T14
, typename T15, typename T16, typename T17, typename T18, typename T19
, typename T20, typename T21, typename T22, typename T23, typename T24
, typename T25, typename T26, typename T27, typename T28, typename T29
>
struct vector30
: v_item<
T29
, vector29< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 >
>
{
typedef vector30 type;
};
}}

173
3rdparty/boost/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp vendored
View File

@ -1,173 +0,0 @@
// Copyright Aleksey Gurtovoy 2000-2004
//
// 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)
//
// Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
>
struct vector21_c
: v_item<
integral_c< T,C20 >
, vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >
>
{
typedef vector21_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21
>
struct vector22_c
: v_item<
integral_c< T,C21 >
, vector21_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20 >
>
{
typedef vector22_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22
>
struct vector23_c
: v_item<
integral_c< T,C22 >
, vector22_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21 >
>
{
typedef vector23_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23
>
struct vector24_c
: v_item<
integral_c< T,C23 >
, vector23_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22 >
>
{
typedef vector24_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24
>
struct vector25_c
: v_item<
integral_c< T,C24 >
, vector24_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23 >
>
{
typedef vector25_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25
>
struct vector26_c
: v_item<
integral_c< T,C25 >
, vector25_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24 >
>
{
typedef vector26_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26
>
struct vector27_c
: v_item<
integral_c< T,C26 >
, vector26_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25 >
>
{
typedef vector27_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27
>
struct vector28_c
: v_item<
integral_c< T,C27 >
, vector27_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26 >
>
{
typedef vector28_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28
>
struct vector29_c
: v_item<
integral_c< T,C28 >
, vector28_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27 >
>
{
typedef vector29_c type;
typedef T value_type;
};
template<
typename T
, T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10
, T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20
, T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29
>
struct vector30_c
: v_item<
integral_c< T,C29 >
, vector29_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28 >
>
{
typedef vector30_c type;
typedef T value_type;
};
}}

Some files were not shown because too many files have changed in this diff Show More