diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_forward.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_forward.hpp new file mode 100644 index 00000000..8fdec65b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_forward.hpp @@ -0,0 +1,52 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// detail/sp_forward.hpp +// +// Copyright 2008,2012 Peter Dimov +// +// 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 + +namespace boost +{ + +namespace detail +{ + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) + +#if defined( BOOST_GCC ) && __GNUC__ * 100 + __GNUC_MINOR__ <= 404 + +// GCC 4.4 supports an outdated version of rvalue references and creates a copy of the forwarded object. +// This results in warnings 'returning reference to temporary'. Therefore we use a special version similar to std::forward. +template< class T > T&& sp_forward( T && t ) BOOST_NOEXCEPT +{ + return t; +} + +#else + +template< class T > T&& sp_forward( T & t ) BOOST_NOEXCEPT +{ + return static_cast< T&& >( t ); +} + +#endif + +#endif + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_has_sync.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_has_sync.hpp new file mode 100644 index 00000000..e1debf0c --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_has_sync.hpp @@ -0,0 +1,69 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/smart_ptr/detail/sp_has_sync.hpp +// +// Copyright (c) 2008, 2009 Peter Dimov +// +// 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) +// +// Defines the BOOST_SP_HAS_SYNC macro if the __sync_* intrinsics +// are available. +// + +#ifndef BOOST_SP_NO_SYNC + +#if !defined( __c2__ ) && defined( __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 ) + +# define BOOST_SP_HAS_SYNC + +#elif defined( __IBMCPP__ ) && ( __IBMCPP__ >= 1210 ) && !defined( __COMPILER_VER__ ) + +# define BOOST_SP_HAS_SYNC + +#elif !defined( __c2__ ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) + +#define BOOST_SP_HAS_SYNC + +#if defined( __arm__ ) || defined( __armel__ ) +#undef BOOST_SP_HAS_SYNC +#endif + +#if defined( __hppa ) || defined( __hppa__ ) +#undef BOOST_SP_HAS_SYNC +#endif + +#if defined( __m68k__ ) +#undef BOOST_SP_HAS_SYNC +#endif + +#if defined( __sh__ ) +#undef BOOST_SP_HAS_SYNC +#endif + +#if defined( __sparc__ ) +#undef BOOST_SP_HAS_SYNC +#endif + +#if defined( __INTEL_COMPILER ) && !defined( __ia64__ ) && ( __INTEL_COMPILER < 1110 ) +#undef BOOST_SP_HAS_SYNC +#endif + +#if defined(__PATHSCALE__) && ((__PATHCC__ == 4) && (__PATHCC_MINOR__ < 9)) +#undef BOOST_SP_HAS_SYNC +#endif + +#endif + +#endif // #ifndef BOOST_SP_NO_SYNC + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_interlocked.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_interlocked.hpp new file mode 100644 index 00000000..e181b8ee --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_interlocked.hpp @@ -0,0 +1,173 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/sp_interlocked.hpp +// +// Copyright 2005, 2014 Peter Dimov +// +// 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_SP_HAS_INTRIN_H + +// VC9 has intrin.h, but it collides with +#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600 + +# define BOOST_SP_HAS_INTRIN_H + +// Unlike __MINGW64__, __MINGW64_VERSION_MAJOR is defined by MinGW-w64 for both 32 and 64-bit targets. +#elif defined( __MINGW64_VERSION_MAJOR ) + +// MinGW-w64 provides intrin.h for both 32 and 64-bit targets. +# define BOOST_SP_HAS_INTRIN_H + +#elif defined( __LP64__ ) + +// We have to use intrin.h on Cygwin 64 +# define BOOST_SP_HAS_INTRIN_H + +// Intel C++ on Windows on VC10+ stdlib +#elif defined( BOOST_INTEL_WIN ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520 + +# define BOOST_SP_HAS_INTRIN_H + +// clang-cl on Windows on VC10+ stdlib +#elif defined( __clang__ ) && defined( _MSC_VER ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520 + +# define BOOST_SP_HAS_INTRIN_H + +#endif + +#if defined( BOOST_USE_WINDOWS_H ) + +# include + +# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd + +#elif defined( BOOST_USE_INTRIN_H ) || defined( BOOST_SP_HAS_INTRIN_H ) + +#include + +# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd + +#elif defined( _WIN32_WCE ) + +#if _WIN32_WCE >= 0x600 + +extern "C" long __cdecl _InterlockedIncrement( long volatile * ); +extern "C" long __cdecl _InterlockedDecrement( long volatile * ); +extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __cdecl _InterlockedExchange( long volatile *, long ); +extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long ); + +# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd + +#else + +// under Windows CE we still have old-style Interlocked* functions + +extern "C" long __cdecl InterlockedIncrement( long* ); +extern "C" long __cdecl InterlockedDecrement( long* ); +extern "C" long __cdecl InterlockedCompareExchange( long*, long, long ); +extern "C" long __cdecl InterlockedExchange( long*, long ); +extern "C" long __cdecl InterlockedExchangeAdd( long*, long ); + +# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd + +#endif + +#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN ) + +#if defined( __CLRCALL_PURE_OR_CDECL ) + +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long ); +extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long ); + +#else + +extern "C" long __cdecl _InterlockedIncrement( long volatile * ); +extern "C" long __cdecl _InterlockedDecrement( long volatile * ); +extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __cdecl _InterlockedExchange( long volatile *, long ); +extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long ); + +# if defined( BOOST_MSVC ) && BOOST_MSVC == 1310 +//From MSDN, Visual Studio .NET 2003 spedific: To declare one of the interlocked functions +//for use as an intrinsic, the function must be declared with the leading underscore and +//the new function must appear in a #pragma intrinsic statement. +# pragma intrinsic( _InterlockedIncrement ) +# pragma intrinsic( _InterlockedDecrement ) +# pragma intrinsic( _InterlockedCompareExchange ) +# pragma intrinsic( _InterlockedExchange ) +# pragma intrinsic( _InterlockedExchangeAdd ) +# endif + +#endif + +# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd + +#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ ) + +namespace boost +{ + +namespace detail +{ + +extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement( long volatile * ); +extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volatile * ); +extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long ); +extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long ); +extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long ); + +} // namespace detail + +} // namespace boost + +# define BOOST_SP_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement +# define BOOST_SP_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement +# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange +# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd + +#else + +# error "Interlocked intrinsics not available" + +#endif + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_noexcept.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_noexcept.hpp new file mode 100644 index 00000000..1287ba49 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_noexcept.hpp @@ -0,0 +1,48 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// detail/sp_noexcept.hpp +// +// Copyright 2016, 2017 Peter Dimov +// +// 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_SP_NOEXCEPT + +#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1700 && BOOST_MSVC < 1900 + +# define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW + +#else + +# define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT + +#endif + +// BOOST_SP_NOEXCEPT_WITH_ASSERT + +#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) ) + +# define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT + +#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) ) + +# define BOOST_SP_NOEXCEPT_WITH_ASSERT + +#else + +# define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT + +#endif + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_nullptr_t.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_nullptr_t.hpp new file mode 100644 index 00000000..219ae807 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_nullptr_t.hpp @@ -0,0 +1,45 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// detail/sp_nullptr_t.hpp +// +// Copyright 2013 Peter Dimov +// +// 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 +#include + +#if !defined( BOOST_NO_CXX11_NULLPTR ) + +namespace boost +{ + +namespace detail +{ + +#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) ) + + typedef decltype(nullptr) sp_nullptr_t; + +#else + + typedef std::nullptr_t sp_nullptr_t; + +#endif + +} // namespace detail + +} // namespace boost + +#endif // !defined( BOOST_NO_CXX11_NULLPTR ) + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_typeinfo_.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_typeinfo_.hpp new file mode 100644 index 00000000..287bf728 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/sp_typeinfo_.hpp @@ -0,0 +1,58 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SP_TYPEINFO_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SP_TYPEINFO_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// smart_ptr/detail/sp_typeinfo_.hpp +// +// Copyright 2007, 2019 Peter Dimov +// +// 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 + +#if defined( BOOST_NO_TYPEID ) || defined( BOOST_NO_STD_TYPEINFO ) + +#include + +namespace boost +{ + +namespace detail +{ + +typedef boost::core::typeinfo sp_typeinfo_; + +} // namespace detail + +} // namespace boost + +#define BOOST_SP_TYPEID_(T) BOOST_CORE_TYPEID(T) + +#else // defined( BOOST_NO_TYPEID ) || defined( BOOST_NO_STD_TYPEINFO ) + +#include + +namespace boost +{ + +namespace detail +{ + +typedef std::type_info sp_typeinfo_; + +} // namespace detail + +} // namespace boost + +#define BOOST_SP_TYPEID_(T) typeid(T) + +#endif // defined( BOOST_NO_TYPEID ) || defined( BOOST_NO_STD_TYPEINFO ) + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_TYPEINFO_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock.hpp new file mode 100644 index 00000000..0b618dfc --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock.hpp @@ -0,0 +1,68 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/spinlock.hpp +// +// Copyright (c) 2008 Peter Dimov +// +// 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) +// +// struct spinlock +// { +// void lock(); +// bool try_lock(); +// void unlock(); +// +// class scoped_lock; +// }; +// +// #define BOOST_DETAIL_SPINLOCK_INIT +// + +#include +#include + +#if defined( BOOST_SP_USE_STD_ATOMIC ) +# if !defined( __clang__ ) +# include +# else +// Clang (at least up to 3.4) can't compile spinlock_pool when +// using std::atomic, so substitute the __sync implementation instead. +# include +# endif + +#elif defined( BOOST_SP_USE_PTHREADS ) +# include + +#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC ) +# include + +#elif defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ ) +# include + +#elif defined( BOOST_SP_HAS_SYNC ) +# include + +#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# include + +#elif defined(BOOST_HAS_PTHREADS) +# include + +#elif !defined(BOOST_HAS_THREADS) +# include + +#else +# error Unrecognized threading platform +#endif + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_gcc_arm.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_gcc_arm.hpp new file mode 100644 index 00000000..24d08a88 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_gcc_arm.hpp @@ -0,0 +1,121 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED + +// +// Copyright (c) 2008, 2011 Peter Dimov +// +// 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 + +#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7S__) + +# define BOOST_SP_ARM_BARRIER "dmb" +# define BOOST_SP_ARM_HAS_LDREX + +#elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) + +# define BOOST_SP_ARM_BARRIER "mcr p15, 0, r0, c7, c10, 5" +# define BOOST_SP_ARM_HAS_LDREX + +#else + +# define BOOST_SP_ARM_BARRIER "" + +#endif + +namespace boost +{ + +namespace detail +{ + +class spinlock +{ +public: + + int v_; + +public: + + bool try_lock() + { + int r; + +#ifdef BOOST_SP_ARM_HAS_LDREX + + __asm__ __volatile__( + "ldrex %0, [%2]; \n" + "cmp %0, %1; \n" + "strexne %0, %1, [%2]; \n" + BOOST_SP_ARM_BARRIER : + "=&r"( r ): // outputs + "r"( 1 ), "r"( &v_ ): // inputs + "memory", "cc" ); + +#else + + __asm__ __volatile__( + "swp %0, %1, [%2];\n" + BOOST_SP_ARM_BARRIER : + "=&r"( r ): // outputs + "r"( 1 ), "r"( &v_ ): // inputs + "memory", "cc" ); + +#endif + + return r == 0; + } + + void lock() + { + for( unsigned k = 0; !try_lock(); ++k ) + { + boost::detail::yield( k ); + } + } + + void unlock() + { + __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" ); + *const_cast< int volatile* >( &v_ ) = 0; + __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" ); + } + +public: + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( spinlock & sp ): sp_( sp ) + { + sp.lock(); + } + + ~scoped_lock() + { + sp_.unlock(); + } + }; +}; + +} // namespace detail +} // namespace boost + +#define BOOST_DETAIL_SPINLOCK_INIT {0} + +#undef BOOST_SP_ARM_BARRIER +#undef BOOST_SP_ARM_HAS_LDREX + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_nt.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_nt.hpp new file mode 100644 index 00000000..1f399d0d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_nt.hpp @@ -0,0 +1,89 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_NT_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_NT_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// Copyright (c) 2008 Peter Dimov +// +// 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 + +namespace boost +{ + +namespace detail +{ + +class spinlock +{ +public: + + bool locked_; + +public: + + inline bool try_lock() + { + if( locked_ ) + { + return false; + } + else + { + locked_ = true; + return true; + } + } + + inline void lock() + { + BOOST_ASSERT( !locked_ ); + locked_ = true; + } + + inline void unlock() + { + BOOST_ASSERT( locked_ ); + locked_ = false; + } + +public: + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( spinlock & sp ): sp_( sp ) + { + sp.lock(); + } + + ~scoped_lock() + { + sp_.unlock(); + } + }; +}; + +} // namespace detail +} // namespace boost + +#define BOOST_DETAIL_SPINLOCK_INIT { false } + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_NT_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_pool.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_pool.hpp new file mode 100644 index 00000000..39cf180b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_pool.hpp @@ -0,0 +1,91 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/detail/spinlock_pool.hpp +// +// Copyright (c) 2008 Peter Dimov +// +// 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) +// +// spinlock_pool<0> is reserved for atomic<>, when/if it arrives +// spinlock_pool<1> is reserved for shared_ptr reference counts +// spinlock_pool<2> is reserved for shared_ptr atomic access +// + +#include +#include +#include + +namespace boost +{ + +namespace detail +{ + +template< int M > class spinlock_pool +{ +private: + + static spinlock pool_[ 41 ]; + +public: + + static spinlock & spinlock_for( void const * pv ) + { +#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64 + std::size_t i = reinterpret_cast< unsigned long long >( pv ) % 41; +#else + std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41; +#endif + return pool_[ i ]; + } + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) ) + { + sp_.lock(); + } + + ~scoped_lock() + { + sp_.unlock(); + } + }; +}; + +template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] = +{ + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, + BOOST_DETAIL_SPINLOCK_INIT +}; + +} // namespace detail +} // namespace boost + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_pt.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_pt.hpp new file mode 100644 index 00000000..f9cabfc3 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_pt.hpp @@ -0,0 +1,79 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// Copyright (c) 2008 Peter Dimov +// +// 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 + +namespace boost +{ + +namespace detail +{ + +class spinlock +{ +public: + + pthread_mutex_t v_; + +public: + + bool try_lock() + { + return pthread_mutex_trylock( &v_ ) == 0; + } + + void lock() + { + pthread_mutex_lock( &v_ ); + } + + void unlock() + { + pthread_mutex_unlock( &v_ ); + } + +public: + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( spinlock & sp ): sp_( sp ) + { + sp.lock(); + } + + ~scoped_lock() + { + sp_.unlock(); + } + }; +}; + +} // namespace detail +} // namespace boost + +#define BOOST_DETAIL_SPINLOCK_INIT { PTHREAD_MUTEX_INITIALIZER } + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_std_atomic.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_std_atomic.hpp new file mode 100644 index 00000000..b1d1eea7 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_std_atomic.hpp @@ -0,0 +1,84 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// Copyright (c) 2014 Peter Dimov +// +// 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 +#include +#include + +namespace boost +{ + +namespace detail +{ + +class spinlock +{ +public: + + std::atomic_flag v_; + +public: + + bool try_lock() BOOST_NOEXCEPT + { + return !v_.test_and_set( std::memory_order_acquire ); + } + + void lock() BOOST_NOEXCEPT + { + for( unsigned k = 0; !try_lock(); ++k ) + { + boost::detail::yield( k ); + } + } + + void unlock() BOOST_NOEXCEPT + { + v_ .clear( std::memory_order_release ); + } + +public: + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( spinlock & sp ) BOOST_NOEXCEPT: sp_( sp ) + { + sp.lock(); + } + + ~scoped_lock() /*BOOST_NOEXCEPT*/ + { + sp_.unlock(); + } + }; +}; + +} // namespace detail +} // namespace boost + +#define BOOST_DETAIL_SPINLOCK_INIT { ATOMIC_FLAG_INIT } + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_sync.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_sync.hpp new file mode 100644 index 00000000..a7145c5a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_sync.hpp @@ -0,0 +1,87 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// Copyright (c) 2008 Peter Dimov +// +// 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 + +#if defined( __ia64__ ) && defined( __INTEL_COMPILER ) +# include +#endif + +namespace boost +{ + +namespace detail +{ + +class spinlock +{ +public: + + int v_; + +public: + + bool try_lock() + { + int r = __sync_lock_test_and_set( &v_, 1 ); + return r == 0; + } + + void lock() + { + for( unsigned k = 0; !try_lock(); ++k ) + { + boost::detail::yield( k ); + } + } + + void unlock() + { + __sync_lock_release( &v_ ); + } + +public: + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( spinlock & sp ): sp_( sp ) + { + sp.lock(); + } + + ~scoped_lock() + { + sp_.unlock(); + } + }; +}; + +} // namespace detail +} // namespace boost + +#define BOOST_DETAIL_SPINLOCK_INIT {0} + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_w32.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_w32.hpp new file mode 100644 index 00000000..d34e4fc2 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/spinlock_w32.hpp @@ -0,0 +1,113 @@ +#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_W32_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_SPINLOCK_W32_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// Copyright (c) 2008 Peter Dimov +// +// 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 +#include + +// BOOST_COMPILER_FENCE + +#if defined(__INTEL_COMPILER) + +#define BOOST_COMPILER_FENCE __memory_barrier(); + +#elif defined( _MSC_VER ) && _MSC_VER >= 1310 + +extern "C" void _ReadWriteBarrier(); +#pragma intrinsic( _ReadWriteBarrier ) + +#define BOOST_COMPILER_FENCE _ReadWriteBarrier(); + +#elif defined(__GNUC__) + +#define BOOST_COMPILER_FENCE __asm__ __volatile__( "" : : : "memory" ); + +#else + +#define BOOST_COMPILER_FENCE + +#endif + +// + +namespace boost +{ + +namespace detail +{ + +class spinlock +{ +public: + + long v_; + +public: + + bool try_lock() + { + long r = BOOST_SP_INTERLOCKED_EXCHANGE( &v_, 1 ); + + BOOST_COMPILER_FENCE + + return r == 0; + } + + void lock() + { + for( unsigned k = 0; !try_lock(); ++k ) + { + boost::detail::yield( k ); + } + } + + void unlock() + { + BOOST_COMPILER_FENCE + *const_cast< long volatile* >( &v_ ) = 0; + } + +public: + + class scoped_lock + { + private: + + spinlock & sp_; + + scoped_lock( scoped_lock const & ); + scoped_lock & operator=( scoped_lock const & ); + + public: + + explicit scoped_lock( spinlock & sp ): sp_( sp ) + { + sp.lock(); + } + + ~scoped_lock() + { + sp_.unlock(); + } + }; +}; + +} // namespace detail +} // namespace boost + +#define BOOST_DETAIL_SPINLOCK_INIT {0} + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_W32_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/yield_k.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/yield_k.hpp new file mode 100644 index 00000000..e9c41b95 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/smart_ptr/detail/yield_k.hpp @@ -0,0 +1,183 @@ +#ifndef BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED +#define BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED + +// MS compatible compilers support #pragma once + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// yield_k.hpp +// +// Copyright (c) 2008 Peter Dimov +// Copyright (c) Microsoft Corporation 2014 +// +// void yield( unsigned k ); +// +// Typical use: +// +// for( unsigned k = 0; !try_lock(); ++k ) yield( k ); +// +// 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 +#include + +#if BOOST_PLAT_WINDOWS_RUNTIME +#include +#endif + +// BOOST_SMT_PAUSE + +#if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) ) && !defined(__c2__) + +extern "C" void _mm_pause(); + +#define BOOST_SMT_PAUSE _mm_pause(); + +#elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) ) + +#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" ); + +#endif + +// + +#if defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ ) + +#if defined( BOOST_USE_WINDOWS_H ) +# include +#endif + +namespace boost +{ + +namespace detail +{ + +#if !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME + +#if defined(__clang__) && defined(__x86_64__) +// clang x64 warns that __stdcall is ignored +# define BOOST_SP_STDCALL +#else +# define BOOST_SP_STDCALL __stdcall +#endif + +#if defined(__LP64__) // Cygwin 64 + extern "C" __declspec(dllimport) void BOOST_SP_STDCALL Sleep( unsigned int ms ); +#else + extern "C" __declspec(dllimport) void BOOST_SP_STDCALL Sleep( unsigned long ms ); +#endif + +#undef BOOST_SP_STDCALL + +#endif // !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME + +inline void yield( unsigned k ) BOOST_NOEXCEPT +{ + if( k < 4 ) + { + } +#if defined( BOOST_SMT_PAUSE ) + else if( k < 16 ) + { + BOOST_SMT_PAUSE + } +#endif +#if !BOOST_PLAT_WINDOWS_RUNTIME + else if( k < 32 ) + { + Sleep( 0 ); + } + else + { + Sleep( 1 ); + } +#else + else + { + // Sleep isn't supported on the Windows Runtime. + std::this_thread::yield(); + } +#endif +} + +} // namespace detail + +} // namespace boost + +#elif defined( BOOST_HAS_PTHREADS ) + +#ifndef _AIX +#include +#else + // AIX's sched.h defines ::var which sometimes conflicts with Lambda's var + extern "C" int sched_yield(void); +#endif + +#include + +namespace boost +{ + +namespace detail +{ + +inline void yield( unsigned k ) +{ + if( k < 4 ) + { + } +#if defined( BOOST_SMT_PAUSE ) + else if( k < 16 ) + { + BOOST_SMT_PAUSE + } +#endif + else if( k < 32 || k & 1 ) + { + sched_yield(); + } + else + { + // g++ -Wextra warns on {} or {0} + struct timespec rqtp = { 0, 0 }; + + // POSIX says that timespec has tv_sec and tv_nsec + // But it doesn't guarantee order or placement + + rqtp.tv_sec = 0; + rqtp.tv_nsec = 1000; + + nanosleep( &rqtp, 0 ); + } +} + +} // namespace detail + +} // namespace boost + +#else + +namespace boost +{ + +namespace detail +{ + +inline void yield( unsigned ) +{ +} + +} // namespace detail + +} // namespace boost + +#endif + +#endif // #ifndef BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/api_config.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/api_config.hpp new file mode 100644 index 00000000..28b8bece --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/api_config.hpp @@ -0,0 +1,42 @@ +// boost/system/api_config.hpp -------------------------------------------------------// + +// Copyright Beman Dawes 2003, 2006, 2010 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See http://www.boost.org/libs/system for documentation. + +//--------------------------------------------------------------------------------------// + +// Boost.System calls operating system API functions to implement system error category +// functions. Usually there is no question as to which API is to be used. +// +// In the case of MinGW or Cygwin/MinGW, however, both POSIX and Windows API's are +// available. Chaos ensues if other code thinks one is in use when Boost.System was +// actually built with the other. This header centralizes the API choice and prevents +// user definition of API macros, thus elminating the possibility of mismatches and the +// need to test configurations with little or no practical value. +// + +//--------------------------------------------------------------------------------------// + +#ifndef BOOST_SYSTEM_API_CONFIG_HPP +#define BOOST_SYSTEM_API_CONFIG_HPP + +# if defined(BOOST_POSIX_API) || defined(BOOST_WINDOWS_API) +# error user defined BOOST_POSIX_API or BOOST_WINDOWS_API not supported +# endif + +// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use +// Cygwin/MinGW does not predefine _WIN32. +// Standalone MinGW and all other known Windows compilers do predefine _WIN32 +// Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too. + +# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin +# define BOOST_WINDOWS_API +# else +# define BOOST_POSIX_API +# endif + +#endif // BOOST_SYSTEM_API_CONFIG_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/config.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/config.hpp new file mode 100644 index 00000000..1e5f6865 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/config.hpp @@ -0,0 +1,50 @@ +// boost/system/config.hpp -----------------------------------------------------------// + +// Copyright Beman Dawes 2003, 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/system for documentation. + +#ifndef BOOST_SYSTEM_CONFIG_HPP +#define BOOST_SYSTEM_CONFIG_HPP + +#include +#include // for BOOST_POSIX_API or BOOST_WINDOWS_API + +// This header implemented separate compilation features as described in +// http://www.boost.org/more/separate_compilation.html +// +// It's only retained for compatibility now that the library is header-only. + +// normalize macros ------------------------------------------------------------------// + +#if !defined(BOOST_SYSTEM_DYN_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK) \ + && !defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_ALL_STATIC_LINK) +# define BOOST_SYSTEM_STATIC_LINK +#endif + +#if defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_SYSTEM_DYN_LINK) +# define BOOST_SYSTEM_DYN_LINK +#elif defined(BOOST_ALL_STATIC_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK) +# define BOOST_SYSTEM_STATIC_LINK +#endif + +#if defined(BOOST_SYSTEM_DYN_LINK) && defined(BOOST_SYSTEM_STATIC_LINK) +# error Must not define both BOOST_SYSTEM_DYN_LINK and BOOST_SYSTEM_STATIC_LINK +#endif + +// enable dynamic or static linking as requested --------------------------------------// + +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK) +# if defined(BOOST_SYSTEM_SOURCE) +# define BOOST_SYSTEM_DECL BOOST_SYMBOL_EXPORT +# else +# define BOOST_SYSTEM_DECL BOOST_SYMBOL_IMPORT +# endif +#else +# define BOOST_SYSTEM_DECL +#endif + +#endif // BOOST_SYSTEM_CONFIG_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/cygwin_error.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/cygwin_error.hpp new file mode 100644 index 00000000..4f91cf3d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/cygwin_error.hpp @@ -0,0 +1,56 @@ +// boost/system/cygwin_error.hpp -------------------------------------------// + +// Copyright Beman Dawes 2007 + +// 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 library home page at http://www.boost.org/libs/system + +#ifndef BOOST_SYSTEM_CYGWIN_ERROR_HPP +#define BOOST_SYSTEM_CYGWIN_ERROR_HPP + +// This header is effectively empty for compiles on operating systems where +// it is not applicable. + +# ifdef __CYGWIN__ + +#include + +namespace boost +{ + namespace system + { + // To construct an error_code after a API error: + // + // error_code( errno, system_category() ) + + // User code should use the portable "posix" enums for POSIX errors; this + // allows such code to be portable to non-POSIX systems. For the non-POSIX + // errno values that POSIX-based systems typically provide in addition to + // POSIX values, use the system specific enums below. + + namespace cygwin_error + { + enum cygwin_errno + { + no_net = ENONET, + no_package = ENOPKG, + no_share = ENOSHARE + }; + } // namespace cygwin_error + + template<> struct is_error_code_enum + { static const bool value = true; }; + + namespace cygwin_error + { + inline error_code make_error_code( cygwin_errno e ) + { return error_code( e, system_category() ); } + } + } +} + +#endif // __CYGWIN__ + +#endif // BOOST_SYSTEM_CYGWIN_ERROR_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/config.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/config.hpp new file mode 100644 index 00000000..5742a94d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/config.hpp @@ -0,0 +1,51 @@ +#ifndef BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED +#define BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED + +// Copyright 2018 Peter Dimov +// +// 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/system for documentation. + +#include +#include + +// BOOST_SYSTEM_HAS_SYSTEM_ERROR + +#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) +# define BOOST_SYSTEM_HAS_SYSTEM_ERROR +#endif + +#if BOOST_WORKAROUND(BOOST_GCC, < 40600) +// g++ 4.4's is not good enough +# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR +#endif + +#if defined(BOOST_NO_CXX11_HDR_MUTEX) +// Required for thread-safe map manipulation +# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR +#endif + +// BOOST_SYSTEM_NOEXCEPT +// Retained for backward compatibility + +#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT + +// BOOST_SYSTEM_HAS_CONSTEXPR + +#if !defined(BOOST_NO_CXX14_CONSTEXPR) +# define BOOST_SYSTEM_HAS_CONSTEXPR +#endif + +#if BOOST_WORKAROUND(BOOST_GCC, < 60000) +# undef BOOST_SYSTEM_HAS_CONSTEXPR +#endif + +#if defined(BOOST_SYSTEM_HAS_CONSTEXPR) +# define BOOST_SYSTEM_CONSTEXPR constexpr +#else +# define BOOST_SYSTEM_CONSTEXPR +#endif + +#endif // BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/generic_category.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/generic_category.hpp new file mode 100644 index 00000000..35175f8b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/generic_category.hpp @@ -0,0 +1,101 @@ +// Implementation details of generic_error_category +// +// Copyright 2018 Peter Dimov +// +// 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 library home page at http://www.boost.org/libs/system + +#include + +namespace boost +{ + +namespace system +{ + +namespace detail +{ + +#if defined(__GLIBC__) + +// glibc has two incompatible strerror_r definitions + +inline char const * strerror_r_helper( char const * r, char const * ) BOOST_NOEXCEPT +{ + return r; +} + +inline char const * strerror_r_helper( int r, char const * buffer ) BOOST_NOEXCEPT +{ + return r == 0? buffer: "Unknown error"; +} + +inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT +{ + return strerror_r_helper( strerror_r( ev, buffer, len ), buffer ); +} + +inline std::string generic_error_category_message( int ev ) +{ + char buffer[ 128 ]; + return generic_error_category_message( ev, buffer, sizeof( buffer ) ); +} + +#else + +// std::strerror is thread-safe on everything else, incl. Windows + +# if defined( BOOST_MSVC ) +# pragma warning( push ) +# pragma warning( disable: 4996 ) +# elif defined(__clang__) && defined(__has_warning) +# pragma clang diagnostic push +# if __has_warning("-Wdeprecated-declarations") +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +# endif +# endif + +inline std::string generic_error_category_message( int ev ) +{ + char const * m = std::strerror( ev ); + return m? m: "Unknown error"; +} + +inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT +{ + if( len == 0 ) + { + return buffer; + } + + if( len == 1 ) + { + buffer[0] = 0; + return buffer; + } + + char const * m = std::strerror( ev ); + + if( m == 0 ) return "Unknown error"; + + std::strncpy( buffer, m, len - 1 ); + buffer[ len-1 ] = 0; + + return buffer; +} + +# if defined( BOOST_MSVC ) +# pragma warning( pop ) +# elif defined(__clang__) && defined(__has_warning) +# pragma clang diagnostic pop +# endif + +#endif + +} // namespace detail + +} // namespace system + +} // namespace boost diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/std_interoperability.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/std_interoperability.hpp new file mode 100644 index 00000000..a6ec728e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/std_interoperability.hpp @@ -0,0 +1,180 @@ +// Support for interoperability between Boost.System and +// +// Copyright 2018 Peter Dimov +// +// 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 library home page at http://www.boost.org/libs/system + +#include +#include +#include +#include + +// + +namespace boost +{ + +namespace system +{ + +namespace detail +{ + +class BOOST_SYMBOL_VISIBLE std_category: public std::error_category +{ +private: + + boost::system::error_category const * pc_; + +public: + + explicit std_category( boost::system::error_category const * pc, unsigned id ): pc_( pc ) + { + if( id != 0 ) + { +#if defined(_MSC_VER) && defined(_CPPLIB_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000 + + // Poking into the protected _Addr member of std::error_category + // is not a particularly good programming practice, but what can + // you do + + _Addr = id; + +#endif + } + } + + virtual const char * name() const BOOST_NOEXCEPT + { + return pc_->name(); + } + + virtual std::string message( int ev ) const + { + return pc_->message( ev ); + } + + virtual std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT + { + return pc_->default_error_condition( ev ); + } + + virtual bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT; + virtual bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT; +}; + +inline std::error_category const & to_std_category( boost::system::error_category const & cat ) BOOST_SYMBOL_VISIBLE; + +struct cat_ptr_less +{ + bool operator()( boost::system::error_category const * p1, boost::system::error_category const * p2 ) const BOOST_NOEXCEPT + { + return *p1 < *p2; + } +}; + +inline std::error_category const & to_std_category( boost::system::error_category const & cat ) +{ + if( cat == boost::system::system_category() ) + { + static const std_category system_instance( &cat, 0x1F4D7 ); + return system_instance; + } + else if( cat == boost::system::generic_category() ) + { + static const std_category generic_instance( &cat, 0x1F4D3 ); + return generic_instance; + } + else + { + typedef std::map< boost::system::error_category const *, std::unique_ptr, cat_ptr_less > map_type; + + static map_type map_; + static std::mutex map_mx_; + + std::lock_guard guard( map_mx_ ); + + map_type::iterator i = map_.find( &cat ); + + if( i == map_.end() ) + { + std::unique_ptr p( new std_category( &cat, 0 ) ); + + std::pair r = map_.insert( map_type::value_type( &cat, std::move( p ) ) ); + + i = r.first; + } + + return *i->second; + } +} + +inline bool std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT +{ + if( condition.category() == *this ) + { + boost::system::error_condition bn( condition.value(), *pc_ ); + return pc_->equivalent( code, bn ); + } + else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() ) + { + boost::system::error_condition bn( condition.value(), boost::system::generic_category() ); + return pc_->equivalent( code, bn ); + } + +#ifndef BOOST_NO_RTTI + + else if( std_category const* pc2 = dynamic_cast< std_category const* >( &condition.category() ) ) + { + boost::system::error_condition bn( condition.value(), *pc2->pc_ ); + return pc_->equivalent( code, bn ); + } + +#endif + + else + { + return default_error_condition( code ) == condition; + } +} + +inline bool std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT +{ + if( code.category() == *this ) + { + boost::system::error_code bc( code.value(), *pc_ ); + return pc_->equivalent( bc, condition ); + } + else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() ) + { + boost::system::error_code bc( code.value(), boost::system::generic_category() ); + return pc_->equivalent( bc, condition ); + } + +#ifndef BOOST_NO_RTTI + + else if( std_category const* pc2 = dynamic_cast< std_category const* >( &code.category() ) ) + { + boost::system::error_code bc( code.value(), *pc2->pc_ ); + return pc_->equivalent( bc, condition ); + } +#endif + + else if( *pc_ == boost::system::generic_category() ) + { + return std::generic_category().equivalent( code, condition ); + } + else + { + return false; + } +} + +} // namespace detail + +} // namespace system + +} // namespace boost diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/system_category_posix.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/system_category_posix.hpp new file mode 100644 index 00000000..9a40623d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/system_category_posix.hpp @@ -0,0 +1,132 @@ +// POSIX-specific implementation details of system_error_category +// +// Copyright 2018 Peter Dimov +// +// 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 library home page at http://www.boost.org/libs/system + +namespace boost +{ + +namespace system +{ + +namespace detail +{ + +inline bool is_generic_value( int ev ) BOOST_NOEXCEPT +{ + using namespace errc; + + static int const gen[] = + { + success, + address_family_not_supported, + address_in_use, + address_not_available, + already_connected, + argument_list_too_long, + argument_out_of_domain, + bad_address, + bad_file_descriptor, + bad_message, + broken_pipe, + connection_aborted, + connection_already_in_progress, + connection_refused, + connection_reset, + cross_device_link, + destination_address_required, + device_or_resource_busy, + directory_not_empty, + executable_format_error, + file_exists, + file_too_large, + filename_too_long, + function_not_supported, + host_unreachable, + identifier_removed, + illegal_byte_sequence, + inappropriate_io_control_operation, + interrupted, + invalid_argument, + invalid_seek, + io_error, + is_a_directory, + message_size, + network_down, + network_reset, + network_unreachable, + no_buffer_space, + no_child_process, + no_link, + no_lock_available, + no_message_available, + no_message, + no_protocol_option, + no_space_on_device, + no_stream_resources, + no_such_device_or_address, + no_such_device, + no_such_file_or_directory, + no_such_process, + not_a_directory, + not_a_socket, + not_a_stream, + not_connected, + not_enough_memory, + not_supported, + operation_canceled, + operation_in_progress, + operation_not_permitted, + operation_not_supported, + operation_would_block, + owner_dead, + permission_denied, + protocol_error, + protocol_not_supported, + read_only_file_system, + resource_deadlock_would_occur, + resource_unavailable_try_again, + result_out_of_range, + state_not_recoverable, + stream_timeout, + text_file_busy, + timed_out, + too_many_files_open_in_system, + too_many_files_open, + too_many_links, + too_many_symbolic_link_levels, + value_too_large, + wrong_protocol_type + }; + + int const n = sizeof( gen ) / sizeof( gen[0] ); + + for( int i = 0; i < n; ++i ) + { + if( ev == gen[ i ] ) return true; + } + + return false; +} + +inline error_condition system_category_default_error_condition_posix( int ev ) BOOST_NOEXCEPT +{ + if( is_generic_value( ev ) ) + { + return error_condition( ev, generic_category() ); + } + else + { + return error_condition( ev, system_category() ); + } +} + +} // namespace detail + +} // namespace system + +} // namespace boost diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/system_category_win32.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/system_category_win32.hpp new file mode 100644 index 00000000..da256e1d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/detail/system_category_win32.hpp @@ -0,0 +1,341 @@ +// Windows implementation of system_error_category +// +// Copyright Beman Dawes 2002, 2006 +// Copyright (c) Microsoft Corporation 2014 +// Copyright 2018 Peter Dimov +// +// 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 library home page at http://www.boost.org/libs/system + +#include +#include +#include +#include +#include + +// + +namespace boost +{ + +namespace system +{ + +namespace detail +{ + +#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) ) + +inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len ) +{ +# if defined( BOOST_MSVC ) +# pragma warning( push ) +# pragma warning( disable: 4996 ) +# endif + + _snprintf( buffer, len - 1, "Unknown error (%d)", ev ); + + buffer[ len - 1 ] = 0; + return buffer; + +# if defined( BOOST_MSVC ) +# pragma warning( pop ) +# endif +} + +#else + +inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len ) +{ + std::snprintf( buffer, len, "Unknown error (%d)", ev ); + return buffer; +} + +#endif + +inline boost::winapi::UINT_ message_cp_win32() +{ +#if defined(BOOST_SYSTEM_USE_UTF8) + + return boost::winapi::CP_UTF8_; + +#else + + return boost::winapi::CP_ACP_; + +#endif +} + +inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT +{ + if( len == 0 ) + { + return buffer; + } + + if( len == 1 ) + { + buffer[0] = 0; + return buffer; + } + + boost::winapi::UINT_ const code_page = message_cp_win32(); + + int r = 0; + +#if !defined(BOOST_NO_ANSI_APIS) + + if( code_page == boost::winapi::CP_ACP_ ) + { + using namespace boost::winapi; + + DWORD_ retval = boost::winapi::FormatMessageA( + FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_, + NULL, + ev, + MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language + buffer, + static_cast( len ), + NULL + ); + + r = static_cast( retval ); + } + else + +#endif + + { + using namespace boost::winapi; + + wchar_t * lpMsgBuf = 0; + + DWORD_ retval = boost::winapi::FormatMessageW( + FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_, + NULL, + ev, + MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language + (LPWSTR_) &lpMsgBuf, + 0, + NULL + ); + + if( retval != 0 ) + { + r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, buffer, static_cast( len ), NULL, NULL ); + boost::winapi::LocalFree( lpMsgBuf ); + if ( r != 0 ) --r; // exclude null terminator + } + } + + if( r == 0 ) + { + return unknown_message_win32( ev, buffer, len ); + } + + while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) ) + { + buffer[ --r ] = 0; + } + + if( r > 0 && buffer[ r-1 ] == '.' ) + { + buffer[ --r ] = 0; + } + + return buffer; +} + +struct local_free +{ + void * p_; + + ~local_free() + { + boost::winapi::LocalFree( p_ ); + } +}; + +inline std::string unknown_message_win32( int ev ) +{ + char buffer[ 38 ]; + return unknown_message_win32( ev, buffer, sizeof( buffer ) ); +} + +inline std::string system_category_message_win32( int ev ) +{ + using namespace boost::winapi; + + wchar_t * lpMsgBuf = 0; + + DWORD_ retval = boost::winapi::FormatMessageW( + FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_, + NULL, + ev, + MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language + (LPWSTR_) &lpMsgBuf, + 0, + NULL + ); + + if( retval == 0 ) + { + return unknown_message_win32( ev ); + } + + local_free lf_ = { lpMsgBuf }; + (void)lf_; + + UINT_ const code_page = message_cp_win32(); + + int r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, 0, 0, NULL, NULL ); + + if( r == 0 ) + { + return unknown_message_win32( ev ); + } + + std::string buffer( r, char() ); + + r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL ); + + if( r == 0 ) + { + return unknown_message_win32( ev ); + } + + --r; // exclude null terminator + + while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) ) + { + --r; + } + + if( r > 0 && buffer[ r-1 ] == '.' ) + { + --r; + } + + buffer.resize( r ); + + return buffer; +} + +inline error_condition system_category_default_error_condition_win32( int ev ) BOOST_NOEXCEPT +{ + // When using the Windows Runtime, most system errors are reported as HRESULTs. + // We want to map the common Win32 errors to their equivalent error condition, + // whether or not they are reported via an HRESULT. + +#define BOOST_SYSTEM_FAILED(hr) ((hr) < 0) +#define BOOST_SYSTEM_HRESULT_FACILITY(hr) (((hr) >> 16) & 0x1fff) +#define BOOST_SYSTEM_HRESULT_CODE(hr) ((hr) & 0xFFFF) +#define BOOST_SYSTEM_FACILITY_WIN32 7 + + if( BOOST_SYSTEM_FAILED( ev ) && BOOST_SYSTEM_HRESULT_FACILITY( ev ) == BOOST_SYSTEM_FACILITY_WIN32 ) + { + ev = BOOST_SYSTEM_HRESULT_CODE( ev ); + } + +#undef BOOST_SYSTEM_FAILED +#undef BOOST_SYSTEM_HRESULT_FACILITY +#undef BOOST_SYSTEM_HRESULT_CODE +#undef BOOST_SYSTEM_FACILITY_WIN32 + + using namespace boost::winapi; + using namespace errc; + + // Windows system -> posix_errno decode table + // see WinError.h comments for descriptions of errors + + switch ( ev ) + { + case 0: return make_error_condition( success ); + + case ERROR_ACCESS_DENIED_: return make_error_condition( permission_denied ); + case ERROR_ALREADY_EXISTS_: return make_error_condition( file_exists ); + case ERROR_BAD_UNIT_: return make_error_condition( no_such_device ); + case ERROR_BUFFER_OVERFLOW_: return make_error_condition( filename_too_long ); + case ERROR_BUSY_: return make_error_condition( device_or_resource_busy ); + case ERROR_BUSY_DRIVE_: return make_error_condition( device_or_resource_busy ); + case ERROR_CANNOT_MAKE_: return make_error_condition( permission_denied ); + case ERROR_CANTOPEN_: return make_error_condition( io_error ); + case ERROR_CANTREAD_: return make_error_condition( io_error ); + case ERROR_CANTWRITE_: return make_error_condition( io_error ); + case ERROR_CONNECTION_ABORTED_: return make_error_condition( connection_aborted ); + case ERROR_CURRENT_DIRECTORY_: return make_error_condition( permission_denied ); + case ERROR_DEV_NOT_EXIST_: return make_error_condition( no_such_device ); + case ERROR_DEVICE_IN_USE_: return make_error_condition( device_or_resource_busy ); + case ERROR_DIR_NOT_EMPTY_: return make_error_condition( directory_not_empty ); + case ERROR_DIRECTORY_: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid" + case ERROR_DISK_FULL_: return make_error_condition( no_space_on_device ); + case ERROR_FILE_EXISTS_: return make_error_condition( file_exists ); + case ERROR_FILE_NOT_FOUND_: return make_error_condition( no_such_file_or_directory ); + case ERROR_HANDLE_DISK_FULL_: return make_error_condition( no_space_on_device ); + case ERROR_INVALID_ACCESS_: return make_error_condition( permission_denied ); + case ERROR_INVALID_DRIVE_: return make_error_condition( no_such_device ); + case ERROR_INVALID_FUNCTION_: return make_error_condition( function_not_supported ); + case ERROR_INVALID_HANDLE_: return make_error_condition( invalid_argument ); + case ERROR_INVALID_NAME_: return make_error_condition( invalid_argument ); + case ERROR_LOCK_VIOLATION_: return make_error_condition( no_lock_available ); + case ERROR_LOCKED_: return make_error_condition( no_lock_available ); + case ERROR_NEGATIVE_SEEK_: return make_error_condition( invalid_argument ); + case ERROR_NOACCESS_: return make_error_condition( permission_denied ); + case ERROR_NOT_ENOUGH_MEMORY_: return make_error_condition( not_enough_memory ); + case ERROR_NOT_READY_: return make_error_condition( resource_unavailable_try_again ); + case ERROR_NOT_SAME_DEVICE_: return make_error_condition( cross_device_link ); + case ERROR_OPEN_FAILED_: return make_error_condition( io_error ); + case ERROR_OPEN_FILES_: return make_error_condition( device_or_resource_busy ); + case ERROR_OPERATION_ABORTED_: return make_error_condition( operation_canceled ); + case ERROR_OUTOFMEMORY_: return make_error_condition( not_enough_memory ); + case ERROR_PATH_NOT_FOUND_: return make_error_condition( no_such_file_or_directory ); + case ERROR_READ_FAULT_: return make_error_condition( io_error ); + case ERROR_RETRY_: return make_error_condition( resource_unavailable_try_again ); + case ERROR_SEEK_: return make_error_condition( io_error ); + case ERROR_SHARING_VIOLATION_: return make_error_condition( permission_denied ); + case ERROR_TOO_MANY_OPEN_FILES_: return make_error_condition( too_many_files_open ); + case ERROR_WRITE_FAULT_: return make_error_condition( io_error ); + case ERROR_WRITE_PROTECT_: return make_error_condition( permission_denied ); + case WSAEACCES_: return make_error_condition( permission_denied ); + case WSAEADDRINUSE_: return make_error_condition( address_in_use ); + case WSAEADDRNOTAVAIL_: return make_error_condition( address_not_available ); + case WSAEAFNOSUPPORT_: return make_error_condition( address_family_not_supported ); + case WSAEALREADY_: return make_error_condition( connection_already_in_progress ); + case WSAEBADF_: return make_error_condition( bad_file_descriptor ); + case WSAECONNABORTED_: return make_error_condition( connection_aborted ); + case WSAECONNREFUSED_: return make_error_condition( connection_refused ); + case WSAECONNRESET_: return make_error_condition( connection_reset ); + case WSAEDESTADDRREQ_: return make_error_condition( destination_address_required ); + case WSAEFAULT_: return make_error_condition( bad_address ); + case WSAEHOSTUNREACH_: return make_error_condition( host_unreachable ); + case WSAEINPROGRESS_: return make_error_condition( operation_in_progress ); + case WSAEINTR_: return make_error_condition( interrupted ); + case WSAEINVAL_: return make_error_condition( invalid_argument ); + case WSAEISCONN_: return make_error_condition( already_connected ); + case WSAEMFILE_: return make_error_condition( too_many_files_open ); + case WSAEMSGSIZE_: return make_error_condition( message_size ); + case WSAENAMETOOLONG_: return make_error_condition( filename_too_long ); + case WSAENETDOWN_: return make_error_condition( network_down ); + case WSAENETRESET_: return make_error_condition( network_reset ); + case WSAENETUNREACH_: return make_error_condition( network_unreachable ); + case WSAENOBUFS_: return make_error_condition( no_buffer_space ); + case WSAENOPROTOOPT_: return make_error_condition( no_protocol_option ); + case WSAENOTCONN_: return make_error_condition( not_connected ); + case WSAENOTSOCK_: return make_error_condition( not_a_socket ); + case WSAEOPNOTSUPP_: return make_error_condition( operation_not_supported ); + case WSAEPROTONOSUPPORT_: return make_error_condition( protocol_not_supported ); + case WSAEPROTOTYPE_: return make_error_condition( wrong_protocol_type ); + case WSAETIMEDOUT_: return make_error_condition( timed_out ); + case WSAEWOULDBLOCK_: return make_error_condition( operation_would_block ); + + default: return error_condition( ev, system_category() ); + } +} + +} // namespace detail + +} // namespace system + +} // namespace boost diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/error_code.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/error_code.hpp new file mode 100644 index 00000000..9fb7de3b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/error_code.hpp @@ -0,0 +1,971 @@ +#ifndef BOOST_SYSTEM_ERROR_CODE_HPP_INCLUDED +#define BOOST_SYSTEM_ERROR_CODE_HPP_INCLUDED + +// Copyright Beman Dawes 2006, 2007 +// Copyright Christoper Kohlhoff 2007 +// Copyright Peter Dimov 2017, 2018 +// +// 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 library home page at http://www.boost.org/libs/system + +#include +#include +#include +#include +#include +#include +#include +#include + +// TODO: undef these macros if not already defined +#include + +#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR) +# include +#endif + +#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API) +# error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined +#endif + +namespace boost +{ + +namespace system +{ + +class error_code; // values defined by the operating system +class error_condition; // portable generic values defined below, but ultimately + // based on the POSIX standard + +// "Concept" helpers + +template struct is_error_code_enum +{ + static const bool value = false; +}; + +template struct is_error_condition_enum +{ + static const bool value = false; +}; + +// Generic error_conditions + +namespace errc +{ + +enum errc_t +{ + success = 0, + address_family_not_supported = EAFNOSUPPORT, + address_in_use = EADDRINUSE, + address_not_available = EADDRNOTAVAIL, + already_connected = EISCONN, + argument_list_too_long = E2BIG, + argument_out_of_domain = EDOM, + bad_address = EFAULT, + bad_file_descriptor = EBADF, + bad_message = EBADMSG, + broken_pipe = EPIPE, + connection_aborted = ECONNABORTED, + connection_already_in_progress = EALREADY, + connection_refused = ECONNREFUSED, + connection_reset = ECONNRESET, + cross_device_link = EXDEV, + destination_address_required = EDESTADDRREQ, + device_or_resource_busy = EBUSY, + directory_not_empty = ENOTEMPTY, + executable_format_error = ENOEXEC, + file_exists = EEXIST, + file_too_large = EFBIG, + filename_too_long = ENAMETOOLONG, + function_not_supported = ENOSYS, + host_unreachable = EHOSTUNREACH, + identifier_removed = EIDRM, + illegal_byte_sequence = EILSEQ, + inappropriate_io_control_operation = ENOTTY, + interrupted = EINTR, + invalid_argument = EINVAL, + invalid_seek = ESPIPE, + io_error = EIO, + is_a_directory = EISDIR, + message_size = EMSGSIZE, + network_down = ENETDOWN, + network_reset = ENETRESET, + network_unreachable = ENETUNREACH, + no_buffer_space = ENOBUFS, + no_child_process = ECHILD, + no_link = ENOLINK, + no_lock_available = ENOLCK, + no_message_available = ENODATA, + no_message = ENOMSG, + no_protocol_option = ENOPROTOOPT, + no_space_on_device = ENOSPC, + no_stream_resources = ENOSR, + no_such_device_or_address = ENXIO, + no_such_device = ENODEV, + no_such_file_or_directory = ENOENT, + no_such_process = ESRCH, + not_a_directory = ENOTDIR, + not_a_socket = ENOTSOCK, + not_a_stream = ENOSTR, + not_connected = ENOTCONN, + not_enough_memory = ENOMEM, + not_supported = ENOTSUP, + operation_canceled = ECANCELED, + operation_in_progress = EINPROGRESS, + operation_not_permitted = EPERM, + operation_not_supported = EOPNOTSUPP, + operation_would_block = EWOULDBLOCK, + owner_dead = EOWNERDEAD, + permission_denied = EACCES, + protocol_error = EPROTO, + protocol_not_supported = EPROTONOSUPPORT, + read_only_file_system = EROFS, + resource_deadlock_would_occur = EDEADLK, + resource_unavailable_try_again = EAGAIN, + result_out_of_range = ERANGE, + state_not_recoverable = ENOTRECOVERABLE, + stream_timeout = ETIME, + text_file_busy = ETXTBSY, + timed_out = ETIMEDOUT, + too_many_files_open_in_system = ENFILE, + too_many_files_open = EMFILE, + too_many_links = EMLINK, + too_many_symbolic_link_levels = ELOOP, + value_too_large = EOVERFLOW, + wrong_protocol_type = EPROTOTYPE +}; + +} // namespace errc + +#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED + +namespace posix = errc; +namespace posix_error = errc; + +#endif + +template<> struct is_error_condition_enum +{ + static const bool value = true; +}; + +// class error_category +#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG ) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" +#endif + +#ifdef BOOST_MSVC +#pragma warning( push ) +// 'this' : used in base member initializer list +#pragma warning( disable: 4355 ) +#endif + +std::size_t hash_value( error_code const & ec ); + +class BOOST_SYMBOL_VISIBLE error_category +{ +private: + + friend std::size_t hash_value( error_code const & ec ); + +#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) +public: + + error_category( error_category const & ) = delete; + error_category& operator=( error_category const & ) = delete; + +#else +private: + + error_category( error_category const & ); + error_category& operator=( error_category const & ); + +#endif + +private: + + boost::ulong_long_type id_; + +protected: + +#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) + + ~error_category() = default; + +#else + + // We'd like to make the destructor protected, to make code that deletes + // an error_category* not compile; unfortunately, doing the below makes + // the destructor user-provided and hence breaks use after main, as the + // categories may get destroyed before code that uses them + + // ~error_category() {} + +#endif + + BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 ) + { + } + + explicit BOOST_SYSTEM_CONSTEXPR error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id ) + { + } + +public: + + virtual const char * name() const BOOST_NOEXCEPT = 0; + + virtual error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT; + virtual bool equivalent( int code, const error_condition & condition ) const BOOST_NOEXCEPT; + virtual bool equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT; + + virtual std::string message( int ev ) const = 0; + virtual char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT; + + virtual bool failed( int ev ) const BOOST_NOEXCEPT; + + BOOST_SYSTEM_CONSTEXPR bool operator==( const error_category & rhs ) const BOOST_NOEXCEPT + { + return rhs.id_ == 0? this == &rhs: id_ == rhs.id_; + } + + BOOST_SYSTEM_CONSTEXPR bool operator!=( const error_category & rhs ) const BOOST_NOEXCEPT + { + return !( *this == rhs ); + } + + BOOST_SYSTEM_CONSTEXPR bool operator<( const error_category & rhs ) const BOOST_NOEXCEPT + { + if( id_ < rhs.id_ ) + { + return true; + } + + if( id_ > rhs.id_ ) + { + return false; + } + + if( rhs.id_ != 0 ) + { + return false; // equal + } + + return std::less()( this, &rhs ); + } + +#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR) + + operator std::error_category const & () const; + +#endif +}; + +#ifdef BOOST_MSVC +#pragma warning( pop ) +#endif + +// predefined error categories + +namespace detail +{ + +class BOOST_SYMBOL_VISIBLE generic_error_category: public error_category +{ +public: + + // clang++ 3.8 and below: initialization of const object + // requires a user-provided default constructor + BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT: + error_category( ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDF0D ) + { + } + + const char * name() const BOOST_NOEXCEPT + { + return "generic"; + } + + std::string message( int ev ) const; + char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT; +}; + +class BOOST_SYMBOL_VISIBLE system_error_category: public error_category +{ +public: + + BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT: + error_category( ( boost::ulong_long_type( 0x8FAFD21E ) << 32 ) + 0x25C5E09B ) + { + } + + const char * name() const BOOST_NOEXCEPT + { + return "system"; + } + + error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT; + + std::string message( int ev ) const; + char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT; +}; + +} // namespace detail + +#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG ) +#pragma GCC diagnostic pop +#endif + +// generic_category(), system_category() + +#if defined(BOOST_SYSTEM_HAS_CONSTEXPR) + +namespace detail +{ + +template struct BOOST_SYMBOL_VISIBLE cat_holder +{ + static constexpr system_error_category system_category_instance{}; + static constexpr generic_error_category generic_category_instance{}; +}; + +// Before C++17 it was mandatory to redeclare all static constexpr +#if defined(BOOST_NO_CXX17_INLINE_VARIABLES) +template constexpr system_error_category cat_holder::system_category_instance; +template constexpr generic_error_category cat_holder::generic_category_instance; +#endif + +} // namespace detail + +constexpr error_category const & system_category() BOOST_NOEXCEPT +{ + return detail::cat_holder::system_category_instance; +} + +constexpr error_category const & generic_category() BOOST_NOEXCEPT +{ + return detail::cat_holder::generic_category_instance; +} + +#else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR) + +inline error_category const & system_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE; + +inline error_category const & system_category() BOOST_NOEXCEPT +{ + static const detail::system_error_category system_category_instance; + return system_category_instance; +} + +inline error_category const & generic_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE; + +inline error_category const & generic_category() BOOST_NOEXCEPT +{ + static const detail::generic_error_category generic_category_instance; + return generic_category_instance; +} + +#endif // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR) + +// deprecated synonyms + +#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED + +inline const error_category & get_system_category() { return system_category(); } +inline const error_category & get_generic_category() { return generic_category(); } +inline const error_category & get_posix_category() { return generic_category(); } +static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED = generic_category(); +static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED = generic_category(); +static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED = system_category(); + +#endif + +// enable_if + +namespace detail +{ + +template struct enable_if +{ + typedef T type; +}; + +template struct enable_if +{ +}; + +// failed_impl + +#if !defined(BOOST_SYSTEM_HAS_CONSTEXPR) + +inline bool failed_impl( int ev, error_category const & cat ) +{ + return cat.failed( ev ); +} + +#else + +BOOST_SYSTEM_CONSTEXPR inline bool failed_impl( int ev, error_category const & cat ) +{ + if( cat == system_category() || cat == generic_category() ) + { + return ev != 0; + } + else + { + return cat.failed( ev ); + } +} + +#endif + +} // namespace detail + +// class error_condition + +// error_conditions are portable, error_codes are system or library specific + +class error_condition +{ +private: + + int val_; + bool failed_; + error_category const * cat_; + +public: + + // constructors: + + BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_NOEXCEPT: + val_( 0 ), failed_( false ), cat_( &generic_category() ) + { + } + + BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_NOEXCEPT: + val_( val ), failed_( detail::failed_impl( val, cat ) ), cat_( &cat ) + { + } + + template BOOST_SYSTEM_CONSTEXPR error_condition( ErrorConditionEnum e, + typename detail::enable_if::value>::type* = 0) BOOST_NOEXCEPT + { + *this = make_error_condition( e ); + } + + // modifiers: + + BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT + { + val_ = val; + failed_ = detail::failed_impl( val, cat ); + cat_ = &cat; + } + + template + BOOST_SYSTEM_CONSTEXPR typename detail::enable_if::value, error_condition>::type & + operator=( ErrorConditionEnum val ) BOOST_NOEXCEPT + { + *this = make_error_condition( val ); + return *this; + } + + BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT + { + val_ = 0; + failed_ = false; + cat_ = &generic_category(); + } + + // observers: + + BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT + { + return val_; + } + + BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT + { + return *cat_; + } + + std::string message() const + { + return cat_->message( value() ); + } + + char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT + { + return cat_->message( value(), buffer, len ); + } + + BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT + { + return failed_; + } + +#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + + BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT // true if error + { + return val_ != 0; + } + +#else + + typedef void (*unspecified_bool_type)(); + static void unspecified_bool_true() {} + + BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const BOOST_NOEXCEPT // true if error + { + return val_ != 0? unspecified_bool_true: 0; + } + + BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error + { + return val_ == 0; + } + +#endif + + // relationals: + // the more symmetrical non-member syntax allows enum + // conversions work for both rhs and lhs. + + BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT + { + return lhs.val_ == rhs.val_ && *lhs.cat_ == *rhs.cat_; + } + + BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT + { + return *lhs.cat_ < *rhs.cat_ || ( *lhs.cat_ == *rhs.cat_ && lhs.val_ < rhs.val_ ); + } + +#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR) + + operator std::error_condition () const + { + return std::error_condition( value(), category() ); + } + +#endif +}; + +// class error_code + +// We want error_code to be a value type that can be copied without slicing +// and without requiring heap allocation, but we also want it to have +// polymorphic behavior based on the error category. This is achieved by +// abstract base class error_category supplying the polymorphic behavior, +// and error_code containing a pointer to an object of a type derived +// from error_category. + +class error_code +{ +private: + + int val_; + bool failed_; + const error_category * cat_; + +public: + + // constructors: + + BOOST_SYSTEM_CONSTEXPR error_code() BOOST_NOEXCEPT: + val_( 0 ), failed_( false ), cat_( &system_category() ) + { + } + + BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_NOEXCEPT: + val_( val ), failed_( detail::failed_impl( val, cat ) ), cat_( &cat ) + { + } + + template BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e, + typename detail::enable_if::value>::type* = 0 ) BOOST_NOEXCEPT + { + *this = make_error_code( e ); + } + + // modifiers: + + BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT + { + val_ = val; + failed_ = detail::failed_impl( val, cat ); + cat_ = &cat; + } + + template + BOOST_SYSTEM_CONSTEXPR typename detail::enable_if::value, error_code>::type & + operator=( ErrorCodeEnum val ) BOOST_NOEXCEPT + { + *this = make_error_code( val ); + return *this; + } + + BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT + { + val_ = 0; + failed_ = false; + cat_ = &system_category(); + } + + // observers: + + BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT + { + return val_; + } + + BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT + { + return *cat_; + } + + error_condition default_error_condition() const BOOST_NOEXCEPT + { + return cat_->default_error_condition( value() ); + } + + std::string message() const + { + return cat_->message( value() ); + } + + char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT + { + return cat_->message( value(), buffer, len ); + } + + BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT + { + return failed_; + } + +#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) + + BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT // true if error + { + return val_ != 0; + } + +#else + + typedef void (*unspecified_bool_type)(); + static void unspecified_bool_true() {} + + BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const BOOST_NOEXCEPT // true if error + { + return val_ != 0? unspecified_bool_true: 0; + } + + BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error + { + return val_ == 0; + } + +#endif + + // relationals: + + // the more symmetrical non-member syntax allows enum + // conversions work for both rhs and lhs. + + BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT + { + return lhs.val_ == rhs.val_ && *lhs.cat_ == *rhs.cat_; + } + + BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT + { + return *lhs.cat_ < *rhs.cat_ || ( *lhs.cat_ == *rhs.cat_ && lhs.val_ < rhs.val_ ); + } + +#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR) + + operator std::error_code () const + { + return std::error_code( value(), category() ); + } + +#endif +}; + +} // namespace system + +// boost::throws() + +namespace detail +{ + +// Misuse of the error_code object is turned into a noisy failure by +// poisoning the reference. This particular implementation doesn't +// produce warnings or errors from popular compilers, is very efficient +// (as determined by inspecting generated code), and does not suffer +// from order of initialization problems. In practice, it also seems +// cause user function error handling implementation errors to be detected +// very early in the development cycle. + +inline system::error_code* throws() +{ + // See github.com/boostorg/system/pull/12 by visigoth for why the return + // is poisoned with nonzero rather than (0). A test, test_throws_usage(), + // has been added to error_code_test.cpp, and as visigoth mentioned it + // fails on clang for release builds with a return of 0 but works fine + // with (1). + // Since the undefined behavior sanitizer (-fsanitize=undefined) does not + // allow a reference to be formed to the unaligned address of (1), we use + // (8) instead. + + return reinterpret_cast(8); +} + +} // namespace detail + +inline system::error_code& throws() +{ + return *detail::throws(); +} + +// non-member functions of error_code and error_condition + +namespace system +{ + +BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT +{ + return !( lhs == rhs ); +} + +BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT +{ + return !( lhs == rhs ); +} + +inline bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT +{ + return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() ); +} + +inline bool operator!=( const error_code & lhs, const error_condition & rhs ) BOOST_NOEXCEPT +{ + return !( lhs == rhs ); +} + +inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT +{ + return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() ); +} + +inline bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_NOEXCEPT +{ + return !( lhs == rhs ); +} + +template + inline std::basic_ostream& + operator<< (std::basic_ostream& os, error_code ec) +{ + os << ec.category().name() << ':' << ec.value(); + return os; +} + +inline std::size_t hash_value( error_code const & ec ) +{ + error_category const & cat = ec.category(); + + boost::ulong_long_type id = cat.id_; + + if( id == 0 ) + { + id = reinterpret_cast( &cat ); + } + + boost::ulong_long_type hv = ( boost::ulong_long_type( 0xCBF29CE4 ) << 32 ) + 0x84222325; + boost::ulong_long_type const prime = ( boost::ulong_long_type( 0x00000100 ) << 32 ) + 0x000001B3; + + // id + + hv ^= id; + hv *= prime; + + // value + + hv ^= static_cast( ec.value() ); + hv *= prime; + + return static_cast( hv ); +} + +// make_* functions for errc::errc_t + +namespace errc +{ + +// explicit conversion: +BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) BOOST_NOEXCEPT +{ + return error_code( e, generic_category() ); +} + +// implicit conversion: +BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) BOOST_NOEXCEPT +{ + return error_condition( e, generic_category() ); +} + +} // namespace errc + +// error_category default implementation + +inline error_condition error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT +{ + return error_condition( ev, *this ); +} + +inline bool error_category::equivalent( int code, const error_condition & condition ) const BOOST_NOEXCEPT +{ + return default_error_condition( code ) == condition; +} + +inline bool error_category::equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT +{ + return *this == code.category() && code.value() == condition; +} + +inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT +{ + if( len == 0 ) + { + return buffer; + } + + if( len == 1 ) + { + buffer[0] = 0; + return buffer; + } + +#if !defined(BOOST_NO_EXCEPTIONS) + try +#endif + { + std::string m = this->message( ev ); + +# if defined( BOOST_MSVC ) +# pragma warning( push ) +# pragma warning( disable: 4996 ) +# elif defined(__clang__) && defined(__has_warning) +# pragma clang diagnostic push +# if __has_warning("-Wdeprecated-declarations") +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +# endif +# endif + + std::strncpy( buffer, m.c_str(), len - 1 ); + buffer[ len-1 ] = 0; + +# if defined( BOOST_MSVC ) +# pragma warning( pop ) +# elif defined(__clang__) && defined(__has_warning) +# pragma clang diagnostic pop +# endif + + return buffer; + } +#if !defined(BOOST_NO_EXCEPTIONS) + catch( ... ) + { + return "Message text unavailable"; + } +#endif +} + +inline bool error_category::failed( int ev ) const BOOST_NOEXCEPT +{ + return ev != 0; +} + +} // namespace system + +} // namespace boost + +// generic_error_category implementation + +#include + +inline std::string boost::system::detail::generic_error_category::message( int ev ) const +{ + return generic_error_category_message( ev ); +} + +inline char const * boost::system::detail::generic_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT +{ + return generic_error_category_message( ev, buffer, len ); +} + +// system_error_category implementation + +#if defined(BOOST_WINDOWS_API) + +#include + +inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT +{ + return system_category_default_error_condition_win32( ev ); +} + +inline std::string boost::system::detail::system_error_category::message( int ev ) const +{ + return system_category_message_win32( ev ); +} + +inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT +{ + return system_category_message_win32( ev, buffer, len ); +} + +#else // #if defined(BOOST_WINDOWS_API) + +#include + +inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT +{ + return system_category_default_error_condition_posix( ev ); +} + +inline std::string boost::system::detail::system_error_category::message( int ev ) const +{ + return generic_error_category_message( ev ); +} + +inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT +{ + return generic_error_category_message( ev, buffer, len ); +} + +#endif // #if defined(BOOST_WINDOWS_API) + +// interoperability with std::error_code, std::error_condition + +#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR) + +#include + +inline boost::system::error_category::operator std::error_category const & () const +{ + return boost::system::detail::to_std_category( *this ); +} + +#endif // #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR) + +#endif // BOOST_SYSTEM_ERROR_CODE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/linux_error.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/linux_error.hpp new file mode 100644 index 00000000..d02ce291 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/linux_error.hpp @@ -0,0 +1,110 @@ +// boost/system/linux_error.hpp -------------------------------------------// + +// Copyright Beman Dawes 2007 + +// 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 library home page at http://www.boost.org/libs/system + +#ifndef BOOST_SYSTEM_LINUX_ERROR_HPP +#define BOOST_SYSTEM_LINUX_ERROR_HPP + +// This header is effectively empty for compiles on operating systems where +// it is not applicable. + +#if defined(linux) || defined(__linux) || defined(__linux__) + +#include + +namespace boost +{ + namespace system + { + // To construct an error_code after a API error: + // + // error_code( errno, system_category() ) + + // User code should use the portable "posix" enums for POSIX errors; this + // allows such code to be portable to non-POSIX systems. For the non-POSIX + // errno values that POSIX-based systems typically provide in addition to + // POSIX values, use the system specific enums below. + + namespace linux_error + { + enum linux_errno + { + advertise_error = EADV, + bad_exchange = EBADE, + bad_file_number = EBADFD, + bad_font_format = EBFONT, + bad_request_code = EBADRQC, + bad_request_descriptor = EBADR, + bad_slot = EBADSLT, + channel_range = ECHRNG, + communication_error = ECOMM, + dot_dot_error = EDOTDOT, + exchange_full = EXFULL, + host_down = EHOSTDOWN, + is_named_file_type= EISNAM, + key_expired = EKEYEXPIRED, + key_rejected = EKEYREJECTED, + key_revoked = EKEYREVOKED, + level2_halt= EL2HLT, + level2_no_syncronized= EL2NSYNC, + level3_halt = EL3HLT, + level3_reset = EL3RST, + link_range = ELNRNG, + medium_type = EMEDIUMTYPE, + no_anode= ENOANO, + no_block_device = ENOTBLK, + no_csi = ENOCSI, + no_key = ENOKEY, + no_medium = ENOMEDIUM, + no_network = ENONET, + no_package = ENOPKG, + not_avail = ENAVAIL, + not_named_file_type= ENOTNAM, + not_recoverable = ENOTRECOVERABLE, + not_unique = ENOTUNIQ, + owner_dead = EOWNERDEAD, + protocol_no_supported = EPFNOSUPPORT, + remote_address_changed = EREMCHG, + remote_io_error = EREMOTEIO, + remote_object = EREMOTE, + restart_needed = ERESTART, + shared_library_access = ELIBACC, + shared_library_bad = ELIBBAD, + shared_library_execute = ELIBEXEC, + shared_library_max_ = ELIBMAX, + shared_library_section= ELIBSCN, + shutdown = ESHUTDOWN, + socket_type_not_supported = ESOCKTNOSUPPORT, + srmount_error = ESRMNT, + stream_pipe_error = ESTRPIPE, + too_many_references = ETOOMANYREFS, + too_many_users = EUSERS, + unattached = EUNATCH, + unclean = EUCLEAN + }; + } // namespace linux_error + +# ifdef BOOST_SYSTEM_ENABLE_DEPRECATED + namespace Linux = linux_error; +# endif + + template<> struct is_error_code_enum + { static const bool value = true; }; + + namespace linux_error + { + inline error_code make_error_code( linux_errno e ) + { return error_code( e, system_category() ); } + } + + } // namespace system +} // namespace boost + +#endif // Linux + +#endif // BOOST_SYSTEM_LINUX_ERROR_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/system_error.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/system_error.hpp new file mode 100644 index 00000000..116fd38b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/system_error.hpp @@ -0,0 +1,84 @@ +// Boost system_error.hpp --------------------------------------------------// + +// Copyright Beman Dawes 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_SYSTEM_SYSTEM_ERROR_HPP +#define BOOST_SYSTEM_SYSTEM_ERROR_HPP + +#include +#include +#include +#include + +namespace boost +{ + namespace system + { + // class system_error ------------------------------------------------------------// + + class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error + // BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared + // library can be caught. See svn.boost.org/trac/boost/ticket/3697 + { + public: + explicit system_error( error_code ec ) + : std::runtime_error(""), m_error_code(ec) {} + + system_error( error_code ec, const std::string & what_arg ) + : std::runtime_error(what_arg), m_error_code(ec) {} + + system_error( error_code ec, const char* what_arg ) + : std::runtime_error(what_arg), m_error_code(ec) {} + + system_error( int ev, const error_category & ecat ) + : std::runtime_error(""), m_error_code(ev,ecat) {} + + system_error( int ev, const error_category & ecat, + const std::string & what_arg ) + : std::runtime_error(what_arg), m_error_code(ev,ecat) {} + + system_error( int ev, const error_category & ecat, + const char * what_arg ) + : std::runtime_error(what_arg), m_error_code(ev,ecat) {} + + virtual ~system_error() BOOST_NOEXCEPT_OR_NOTHROW {} + + error_code code() const BOOST_NOEXCEPT { return m_error_code; } + const char * what() const BOOST_NOEXCEPT_OR_NOTHROW; + + private: + error_code m_error_code; + mutable std::string m_what; + }; + + // implementation ------------------------------------------------------// + + inline const char * system_error::what() const BOOST_NOEXCEPT_OR_NOTHROW + // see http://www.boost.org/more/error_handling.html for lazy build rationale + { + if ( m_what.empty() ) + { +#ifndef BOOST_NO_EXCEPTIONS + try +#endif + { + m_what = this->std::runtime_error::what(); + if ( !m_what.empty() ) m_what += ": "; + m_what += m_error_code.message(); + } +#ifndef BOOST_NO_EXCEPTIONS + catch (...) { return std::runtime_error::what(); } +#endif + } + return m_what.c_str(); + } + + } // namespace system +} // namespace boost + +#endif // BOOST_SYSTEM_SYSTEM_ERROR_HPP + + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/windows_error.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/windows_error.hpp new file mode 100644 index 00000000..983436f0 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/system/windows_error.hpp @@ -0,0 +1,128 @@ +// boost/system/windows_error.hpp ------------------------------------------// + +// Copyright Beman Dawes 2007 + +// 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 library home page at http://www.boost.org/libs/system + +#ifndef BOOST_SYSTEM_WINDOWS_ERROR_HPP +#define BOOST_SYSTEM_WINDOWS_ERROR_HPP + +// This header is effectively empty for compiles on operating systems where +// it is not applicable. + +#include + +#ifdef BOOST_WINDOWS_API + +#include + +//// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on +//// either of those platforms include the full windows.h +// +//#if defined(__MINGW32__) || defined(__CYGWIN__) +//#include +//#else +//#include +//#endif + +#include + +namespace boost +{ + namespace system + { + + // Microsoft Windows ---------------------------------------------------// + + // To construct an error_code after a API error: + // + // error_code( ::GetLastError(), system_category() ) + + namespace windows_error + { + enum windows_error_code + { + success = 0, + // These names and values are based on Windows winerror.h + invalid_function = boost::winapi::ERROR_INVALID_FUNCTION_, + file_not_found = boost::winapi::ERROR_FILE_NOT_FOUND_, + path_not_found = boost::winapi::ERROR_PATH_NOT_FOUND_, + too_many_open_files = boost::winapi::ERROR_TOO_MANY_OPEN_FILES_, + access_denied = boost::winapi::ERROR_ACCESS_DENIED_, + invalid_handle = boost::winapi::ERROR_INVALID_HANDLE_, + arena_trashed = boost::winapi::ERROR_ARENA_TRASHED_, + not_enough_memory = boost::winapi::ERROR_NOT_ENOUGH_MEMORY_, + invalid_block = boost::winapi::ERROR_INVALID_BLOCK_, + bad_environment = boost::winapi::ERROR_BAD_ENVIRONMENT_, + bad_format = boost::winapi::ERROR_BAD_FORMAT_, + invalid_access = boost::winapi::ERROR_INVALID_ACCESS_, + outofmemory = boost::winapi::ERROR_OUTOFMEMORY_, + invalid_drive = boost::winapi::ERROR_INVALID_DRIVE_, + current_directory = boost::winapi::ERROR_CURRENT_DIRECTORY_, + not_same_device = boost::winapi::ERROR_NOT_SAME_DEVICE_, + no_more_files = boost::winapi::ERROR_NO_MORE_FILES_, + write_protect = boost::winapi::ERROR_WRITE_PROTECT_, + bad_unit = boost::winapi::ERROR_BAD_UNIT_, + not_ready = boost::winapi::ERROR_NOT_READY_, + bad_command = boost::winapi::ERROR_BAD_COMMAND_, + crc = boost::winapi::ERROR_CRC_, + bad_length = boost::winapi::ERROR_BAD_LENGTH_, + seek = boost::winapi::ERROR_SEEK_, + not_dos_disk = boost::winapi::ERROR_NOT_DOS_DISK_, + sector_not_found = boost::winapi::ERROR_SECTOR_NOT_FOUND_, + out_of_paper = boost::winapi::ERROR_OUT_OF_PAPER_, + write_fault = boost::winapi::ERROR_WRITE_FAULT_, + read_fault = boost::winapi::ERROR_READ_FAULT_, + gen_failure = boost::winapi::ERROR_GEN_FAILURE_, + sharing_violation = boost::winapi::ERROR_SHARING_VIOLATION_, + lock_violation = boost::winapi::ERROR_LOCK_VIOLATION_, + wrong_disk = boost::winapi::ERROR_WRONG_DISK_, + sharing_buffer_exceeded = boost::winapi::ERROR_SHARING_BUFFER_EXCEEDED_, + handle_eof = boost::winapi::ERROR_HANDLE_EOF_, + handle_disk_full= boost::winapi::ERROR_HANDLE_DISK_FULL_, + rem_not_list = boost::winapi::ERROR_REM_NOT_LIST_, + dup_name = boost::winapi::ERROR_DUP_NAME_, + bad_net_path = boost::winapi::ERROR_BAD_NETPATH_, + network_busy = boost::winapi::ERROR_NETWORK_BUSY_, + // ... + file_exists = boost::winapi::ERROR_FILE_EXISTS_, + cannot_make = boost::winapi::ERROR_CANNOT_MAKE_, + // ... + broken_pipe = boost::winapi::ERROR_BROKEN_PIPE_, + open_failed = boost::winapi::ERROR_OPEN_FAILED_, + buffer_overflow = boost::winapi::ERROR_BUFFER_OVERFLOW_, + disk_full= boost::winapi::ERROR_DISK_FULL_, + // ... + lock_failed = boost::winapi::ERROR_LOCK_FAILED_, + busy = boost::winapi::ERROR_BUSY_, + cancel_violation = boost::winapi::ERROR_CANCEL_VIOLATION_, + already_exists = boost::winapi::ERROR_ALREADY_EXISTS_ + // ... + + // TODO: add more Windows errors + }; + + } // namespace windows + +# ifdef BOOST_SYSTEM_ENABLE_DEPRECATED + namespace windows = windows_error; +# endif + + template<> struct is_error_code_enum + { static const bool value = true; }; + + namespace windows_error + { + inline error_code make_error_code( windows_error_code e ) + { return error_code( e, system_category() ); } + } + + } // namespace system +} // namespace boost + +#endif // BOOST_WINDOWS_API + +#endif // BOOST_SYSTEM_WINDOWS_ERROR_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_const.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_const.hpp new file mode 100644 index 00000000..2d601182 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_const.hpp @@ -0,0 +1,52 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_CONST_HPP_INCLUDED +#define BOOST_TT_ADD_CONST_HPP_INCLUDED + +#include + +namespace boost { + +// * convert a type T to const type - add_const +// this is not required since the result is always +// the same as "T const", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_const is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + + template struct add_const + { + typedef T const type; + }; + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + + template struct add_const + { + typedef T& type; + }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using add_const_t = typename add_const::type; + +#endif + +} // namespace boost + +#endif // BOOST_TT_ADD_CONST_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_cv.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_cv.hpp new file mode 100644 index 00000000..425d019b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_cv.hpp @@ -0,0 +1,47 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_ADD_CV_HPP_INCLUDED +#define BOOST_TT_ADD_CV_HPP_INCLUDED + +#include + +namespace boost { + +// * convert a type T to a const volatile type - add_cv +// this is not required since the result is always +// the same as "T const volatile", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_volatile is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + +template struct add_cv{ typedef T const volatile type; }; + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +template struct add_cv{ typedef T& type; }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using add_cv_t = typename add_cv::type; + +#endif + +} // namespace boost + +#endif // BOOST_TT_ADD_CV_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_lvalue_reference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_lvalue_reference.hpp new file mode 100644 index 00000000..26b74e67 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_lvalue_reference.hpp @@ -0,0 +1,33 @@ +// Copyright 2010 John Maddock + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP +#define BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP + +#include + +namespace boost{ + +template struct add_lvalue_reference +{ + typedef typename boost::add_reference::type type; +}; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template struct add_lvalue_reference +{ + typedef T& type; +}; +#endif + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using add_lvalue_reference_t = typename add_lvalue_reference::type; + +#endif + +} + +#endif // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_pointer.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_pointer.hpp new file mode 100644 index 00000000..85ad33a8 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_pointer.hpp @@ -0,0 +1,67 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_POINTER_HPP_INCLUDED +#define BOOST_TT_ADD_POINTER_HPP_INCLUDED + +#include + +namespace boost { + +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x5A0) +// +// For some reason this implementation stops Borlands compiler +// from dropping cv-qualifiers, it still fails with references +// to arrays for some reason though (shrug...) (JM 20021104) +// +template +struct add_pointer +{ + typedef T* type; +}; +template +struct add_pointer +{ + typedef T* type; +}; +template +struct add_pointer +{ + typedef T* type; +}; +template +struct add_pointer +{ + typedef T* type; +}; +template +struct add_pointer +{ + typedef T* type; +}; + +#else + +template +struct add_pointer +{ + typedef typename remove_reference::type no_ref_type; + typedef no_ref_type* type; +}; + +#endif + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using add_pointer_t = typename add_pointer::type; + +#endif + +} // namespace boost + +#endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_reference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_reference.hpp new file mode 100644 index 00000000..33e9bc79 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_reference.hpp @@ -0,0 +1,66 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED +#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED + +#include +#include + +namespace boost { + +namespace detail { + +// +// We can't filter out rvalue_references at the same level as +// references or we get ambiguities from msvc: +// + +template +struct add_reference_impl +{ + typedef T& type; +}; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template +struct add_reference_impl +{ + typedef T&& type; +}; +#endif + +} // namespace detail + +template struct add_reference +{ + typedef typename boost::detail::add_reference_impl::type type; +}; +template struct add_reference +{ + typedef T& type; +}; + +// these full specialisations are always required: +template <> struct add_reference { typedef void type; }; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct add_reference { typedef const void type; }; +template <> struct add_reference { typedef const volatile void type; }; +template <> struct add_reference { typedef volatile void type; }; +#endif + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + +template using add_reference_t = typename add_reference::type; + +#endif + + +} // namespace boost + +#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_rvalue_reference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_rvalue_reference.hpp new file mode 100644 index 00000000..ad64894f --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_rvalue_reference.hpp @@ -0,0 +1,70 @@ +// add_rvalue_reference.hpp ---------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP +#define BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP + +#include + +//----------------------------------------------------------------------------// + +#include +#include + +//----------------------------------------------------------------------------// +// // +// C++03 implementation of // +// 20.9.7.2 Reference modifications [meta.trans.ref] // +// Written by Vicente J. Botet Escriba // +// // +// If T names an object or function type then the member typedef type +// shall name T&&; otherwise, type shall name T. [ Note: This rule reflects +// the semantics of reference collapsing. For example, when a type T names +// a type T1&, the type add_rvalue_reference::type is not an rvalue +// reference. -end note ] +//----------------------------------------------------------------------------// + +namespace boost { + +namespace type_traits_detail { + + template + struct add_rvalue_reference_helper + { typedef T type; }; + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + template + struct add_rvalue_reference_helper + { + typedef T&& type; + }; +#endif + + template + struct add_rvalue_reference_imp + { + typedef typename boost::type_traits_detail::add_rvalue_reference_helper + ::value == false && is_reference::value == false) >::type type; + }; + +} + +template struct add_rvalue_reference +{ + typedef typename boost::type_traits_detail::add_rvalue_reference_imp::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using add_rvalue_reference_t = typename add_rvalue_reference::type; + +#endif + +} // namespace boost + +#endif // BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_volatile.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_volatile.hpp new file mode 100644 index 00000000..253751a5 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/add_volatile.hpp @@ -0,0 +1,46 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ADD_VOLATILE_HPP_INCLUDED +#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED + +#include + +namespace boost { + +// * convert a type T to volatile type - add_volatile +// this is not required since the result is always +// the same as "T volatile", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_volatile is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + +template struct add_volatile{ typedef T volatile type; }; + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +template struct add_volatile{ typedef T& type; }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using add_volatile_t = typename add_volatile::type; + +#endif + +} // namespace boost + +#endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/aligned_storage.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/aligned_storage.hpp new file mode 100644 index 00000000..171f5d45 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/aligned_storage.hpp @@ -0,0 +1,138 @@ +//----------------------------------------------------------------------------- +// boost aligned_storage.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002-2003 +// Eric Friedman, Itay Maman +// +// 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_TT_ALIGNED_STORAGE_HPP +#define BOOST_TT_ALIGNED_STORAGE_HPP + +#include // for std::size_t + +#include +#include +#include +#include +#include +#include + +namespace boost { + +namespace detail { namespace aligned_storage { + +BOOST_STATIC_CONSTANT( + std::size_t + , alignment_of_max_align = ::boost::alignment_of::value + ); + +// +// To be TR1 conforming this must be a POD type: +// +template < + std::size_t size_ + , std::size_t alignment_ +> +struct aligned_storage_imp +{ + union data_t + { + char buf[size_]; + + typename ::boost::type_with_alignment::type align_; + } data_; + void* address() const { return const_cast(this); } +}; +template +struct aligned_storage_imp +{ + union data_t + { + char buf[size]; + ::boost::detail::max_align align_; + } data_; + void* address() const { return const_cast(this); } +}; + +template< std::size_t alignment_ > +struct aligned_storage_imp<0u,alignment_> +{ + /* intentionally empty */ + void* address() const { return 0; } +}; + +}} // namespace detail::aligned_storage + +template < + std::size_t size_ + , std::size_t alignment_ = std::size_t(-1) +> +class aligned_storage : +#ifndef __BORLANDC__ + private +#else + public +#endif + ::boost::detail::aligned_storage::aligned_storage_imp +{ + +public: // constants + + typedef ::boost::detail::aligned_storage::aligned_storage_imp type; + + BOOST_STATIC_CONSTANT( + std::size_t + , size = size_ + ); + BOOST_STATIC_CONSTANT( + std::size_t + , alignment = ( + alignment_ == std::size_t(-1) + ? ::boost::detail::aligned_storage::alignment_of_max_align + : alignment_ + ) + ); + +private: // noncopyable + + aligned_storage(const aligned_storage&); + aligned_storage& operator=(const aligned_storage&); + +public: // structors + + aligned_storage() + { + } + + ~aligned_storage() + { + } + +public: // accessors + + void* address() + { + return static_cast(this)->address(); + } + + const void* address() const + { + return static_cast(this)->address(); + } +}; + +// +// Make sure that is_pod recognises aligned_storage<>::type +// as a POD (Note that aligned_storage<> itself is not a POD): +// +template +struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp > : public true_type{}; + +} // namespace boost + +#endif // BOOST_ALIGNED_STORAGE_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/alignment_of.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/alignment_of.hpp new file mode 100644 index 00000000..7d960e31 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/alignment_of.hpp @@ -0,0 +1,119 @@ + +// (C) Copyright John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED +#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED + +#include +#include + +#include +#include + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4121 4512) // alignment is sensitive to packing +#endif +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#pragma option push -Vx- -Ve- +#endif + +namespace boost { + +template struct alignment_of; + +// get the alignment of some arbitrary type: +namespace detail { + +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4324) // structure was padded due to __declspec(align()) +#endif +template +struct alignment_of_hack +{ + char c; + T t; + alignment_of_hack(); +}; +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +template +struct alignment_logic +{ + BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S); +}; + + +template< typename T > +struct alignment_of_impl +{ +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) + // + // With MSVC both the native __alignof operator + // and our own logic gets things wrong from time to time :-( + // Using a combination of the two seems to make the most of a bad job: + // + BOOST_STATIC_CONSTANT(std::size_t, value = + (::boost::detail::alignment_logic< + sizeof(::boost::detail::alignment_of_hack) - sizeof(T), + __alignof(T) + >::value)); +#elif !defined(BOOST_ALIGNMENT_OF) + BOOST_STATIC_CONSTANT(std::size_t, value = + (::boost::detail::alignment_logic< + sizeof(::boost::detail::alignment_of_hack) - sizeof(T), + sizeof(T) + >::value)); +#else + // + // We put this here, rather than in the definition of + // alignment_of below, because MSVC's __alignof doesn't + // always work in that context for some unexplained reason. + // (See type_with_alignment tests for test cases). + // + BOOST_STATIC_CONSTANT(std::size_t, value = BOOST_ALIGNMENT_OF(T)); +#endif +}; + +} // namespace detail + +template struct alignment_of : public integral_constant::value>{}; + +// references have to be treated specially, assume +// that a reference is just a special pointer: +template struct alignment_of : public alignment_of{}; + +#ifdef __BORLANDC__ +// long double gives an incorrect value of 10 (!) +// unless we do this... +struct long_double_wrapper{ long double ld; }; +template<> struct alignment_of : public alignment_of{}; +#endif + +// void has to be treated specially: +template<> struct alignment_of : integral_constant{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template<> struct alignment_of : integral_constant{}; +template<> struct alignment_of : integral_constant{}; +template<> struct alignment_of : integral_constant{}; +#endif + +} // namespace boost + +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +#pragma option pop +#endif +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/alignment_traits.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/alignment_traits.hpp new file mode 100644 index 00000000..2ed6934d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/alignment_traits.hpp @@ -0,0 +1,15 @@ + +// (C) Copyright John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED +#define BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED + +#include +#include + +#endif // BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/arithmetic_traits.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/arithmetic_traits.hpp new file mode 100644 index 00000000..e4670e6b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/arithmetic_traits.hpp @@ -0,0 +1,20 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// defines traits classes for arithmetic types: +// is_void, is_integral, is_float, is_arithmetic, is_fundamental. + +#ifndef BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED +#define BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED + +#include +#include +#include +#include +#include + +#endif // BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/array_traits.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/array_traits.hpp new file mode 100644 index 00000000..a68ae731 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/array_traits.hpp @@ -0,0 +1,15 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED +#define BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED + +#include + +#endif // BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/broken_compiler_spec.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/broken_compiler_spec.hpp new file mode 100644 index 00000000..030840f1 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/broken_compiler_spec.hpp @@ -0,0 +1,21 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_BROKEN_SPEC_HPP_INCLUDED +#define BOOST_TT_BROKEN_SPEC_HPP_INCLUDED + +// +// This header is deprecated and no longer used by type_traits: +// +#if defined(__GNUC__) || defined(_MSC_VER) +# pragma message("NOTE: Use of this header (boost/type_traits/broken_compiler_spec.hpp) is deprecated") +#endif + +#endif // BOOST_TT_CONFIG_HPP_INCLUDED + + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/common_type.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/common_type.hpp new file mode 100644 index 00000000..7136d3ee --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/common_type.hpp @@ -0,0 +1,152 @@ +#ifndef BOOST_TYPE_TRAITS_COMMON_TYPE_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_COMMON_TYPE_HPP_INCLUDED + +// +// Copyright 2015 Peter Dimov +// +// 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 +#include +#include +#include +#include +#include +#include +#include + +#if defined(BOOST_NO_CXX11_DECLTYPE) +#include +#endif + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include +#endif + +namespace boost +{ + +// variadic common_type + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +template struct common_type +{ +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + +template using common_type_t = typename common_type::type; + +namespace type_traits_detail +{ + +template using common_type_fold = common_type_t, T...>; + +} // namespace type_traits_detail + +template +struct common_type: type_traits_detail::mp_defer +{ +}; + +#else + +template +struct common_type: common_type::type, T...> +{ +}; + +#endif // !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + +#else + +template< + class T1 = void, class T2 = void, class T3 = void, + class T4 = void, class T5 = void, class T6 = void, + class T7 = void, class T8 = void, class T9 = void +> +struct common_type: common_type::type, T3, T4, T5, T6, T7, T8, T9> +{ +}; + +#endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +// one argument + +template struct common_type: boost::decay +{ + BOOST_STATIC_ASSERT_MSG(::boost::is_complete::value || ::boost::is_void::value || ::boost::is_array::value, "Arguments to common_type must both be complete types"); +}; + +// two arguments + +namespace type_traits_detail +{ + +// binary common_type + +#if !defined(BOOST_NO_CXX11_DECLTYPE) + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +#if !defined(BOOST_MSVC) || BOOST_MSVC > 1800 + +// internal compiler error on msvc-12.0 + +template using builtin_common_type = typename boost::decay()? boost::declval(): boost::declval() )>::type; + +template struct common_type_impl: mp_defer +{ +}; + +#else + +template using builtin_common_type = decltype( boost::declval()? boost::declval(): boost::declval() ); + +template struct common_type_impl_2: mp_defer +{ +}; + +template using decay_common_type = typename boost::decay::type>::type; + +template struct common_type_impl: mp_defer +{ +}; + +#endif // !defined(BOOST_MSVC) || BOOST_MSVC > 1800 + +#else + +template struct common_type_impl: boost::decay()? boost::declval(): boost::declval() )> +{ +}; + +#endif // #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + +#endif // #if !defined(BOOST_NO_CXX11_DECLTYPE) + +// decay helper + +template::type, class T2d = typename boost::decay::type> struct common_type_decay_helper: boost::common_type +{ +}; + +template struct common_type_decay_helper: common_type_impl +{ +}; + +} // type_traits_detail + +template struct common_type: type_traits_detail::common_type_decay_helper +{ + BOOST_STATIC_ASSERT_MSG(::boost::is_complete::value || ::boost::is_void::value || ::boost::is_array::value, "Arguments to common_type must both be complete types"); + BOOST_STATIC_ASSERT_MSG(::boost::is_complete::value || ::boost::is_void::value || ::boost::is_array::value, "Arguments to common_type must both be complete types"); +}; + +} // namespace boost + +#endif // #ifndef BOOST_TYPE_TRAITS_COMMON_TYPE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/composite_traits.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/composite_traits.hpp new file mode 100644 index 00000000..985a4c51 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/composite_traits.hpp @@ -0,0 +1,29 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// defines traits classes for composite types: +// is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union. +// + +#ifndef BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED +#define BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include + +#endif // BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED + + + + + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/conditional.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/conditional.hpp new file mode 100644 index 00000000..ec31d8b0 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/conditional.hpp @@ -0,0 +1,28 @@ +// (C) Copyright John Maddock 2010. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED +#define BOOST_TT_CONDITIONAL_HPP_INCLUDED + +#include + +namespace boost { + +template struct conditional { typedef T type; }; +template struct conditional { typedef U type; }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using conditional_t = typename conditional::type; + +#endif + +} // namespace boost + + +#endif // BOOST_TT_CONDITIONAL_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/config.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/config.hpp new file mode 100644 index 00000000..47a06483 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/config.hpp @@ -0,0 +1,21 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_OLD_CONFIG_HPP_INCLUDED +#define BOOST_TT_OLD_CONFIG_HPP_INCLUDED + +// +// This header is deprecated and no longer used by type_traits: +// +#if defined(__GNUC__) || defined(_MSC_VER) +# pragma message("NOTE: Use of this header (boost/type_traits/config.hpp) is deprecated") +#endif + +#endif // BOOST_TT_CONFIG_HPP_INCLUDED + + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/conversion_traits.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/conversion_traits.hpp new file mode 100644 index 00000000..c8e5139b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/conversion_traits.hpp @@ -0,0 +1,17 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu) +// Copyright 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED +#define BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED + +#include + +#endif // BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_cv.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_cv.hpp new file mode 100644 index 00000000..2f3dc37a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_cv.hpp @@ -0,0 +1,40 @@ +#ifndef BOOST_TYPE_TRAITS_COPY_CV_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_COPY_CV_HPP_INCLUDED + +// +// Copyright 2015 Peter Dimov +// +// 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 +#include +#include +#include +#include + +namespace boost +{ + +template struct copy_cv +{ +private: + + typedef typename boost::conditional::value, typename boost::add_const::type, T>::type CT; + +public: + + typedef typename boost::conditional::value, typename boost::add_volatile::type, CT>::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using copy_cv_t = typename copy_cv::type; + +#endif + +} // namespace boost + +#endif // #ifndef BOOST_TYPE_TRAITS_COPY_CV_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_cv_ref.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_cv_ref.hpp new file mode 100644 index 00000000..59cbc66e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_cv_ref.hpp @@ -0,0 +1,31 @@ +/* +Copyright 2019 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_COPY_CV_REF_HPP_INCLUDED +#define BOOST_TT_COPY_CV_REF_HPP_INCLUDED + +#include +#include +#include + +namespace boost { + +template +struct copy_cv_ref { + typedef typename copy_reference::type >::type, U>::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template +using copy_cv_ref_t = typename copy_cv_ref::type; +#endif + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_reference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_reference.hpp new file mode 100644 index 00000000..00566814 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/copy_reference.hpp @@ -0,0 +1,35 @@ +/* +Copyright 2019 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_COPY_REFERENCE_HPP_INCLUDED +#define BOOST_TT_COPY_REFERENCE_HPP_INCLUDED + +#include +#include +#include +#include +#include + +namespace boost { + +template +struct copy_reference { + typedef typename conditional::value, + typename add_rvalue_reference::type, + typename conditional::value, + typename add_lvalue_reference::type, T>::type>::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template +using copy_reference_t = typename copy_reference::type; +#endif + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/cv_traits.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/cv_traits.hpp new file mode 100644 index 00000000..5bd6c4f0 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/cv_traits.hpp @@ -0,0 +1,24 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// defines traits classes for cv-qualified types: +// is_const, is_volatile, remove_const, remove_volatile, remove_cv. + +#ifndef BOOST_TT_CV_TRAITS_HPP_INCLUDED +#define BOOST_TT_CV_TRAITS_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // BOOST_TT_CV_TRAITS_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/decay.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/decay.hpp new file mode 100644 index 00000000..5b28d052 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/decay.hpp @@ -0,0 +1,49 @@ +// (C) Copyright John Maddock & Thorsten Ottosen 2005. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_DECAY_HPP_INCLUDED +#define BOOST_TT_DECAY_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace detail + { + + template struct decay_imp { typedef typename remove_cv::type type; }; + template struct decay_imp { typedef typename remove_bounds::type* type; }; + template struct decay_imp { typedef T* type; }; + + } + + template< class T > + struct decay + { + private: + typedef typename remove_reference::type Ty; + public: + typedef typename boost::detail::decay_imp::value, boost::is_function::value>::type type; + }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using decay_t = typename decay::type; + +#endif + +} // namespace boost + + +#endif // BOOST_TT_DECAY_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/declval.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/declval.hpp new file mode 100644 index 00000000..a050012e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/declval.hpp @@ -0,0 +1,44 @@ +// declval.hpp -------------------------------------------------------------// + +// Copyright 2010 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED + +#include + +//----------------------------------------------------------------------------// + +#include + +//----------------------------------------------------------------------------// +// // +// C++03 implementation of // +// 20.2.4 Function template declval [declval] // +// Written by Vicente J. Botet Escriba // +// // +// 1 The library provides the function template declval to simplify the +// definition of expressions which occur as unevaluated operands. +// 2 Remarks: If this function is used, the program is ill-formed. +// 3 Remarks: The template parameter T of declval may be an incomplete type. +// [ Example: +// +// template +// decltype(static_cast(declval())) convert(From&&); +// +// declares a function template convert which only participates in overloading +// if the type From can be explicitly converted to type To. For another example +// see class template common_type (20.9.7.6). -end example ] +//----------------------------------------------------------------------------// + +namespace boost { + + template + typename add_rvalue_reference::type declval() BOOST_NOEXCEPT; // as unevaluated operand + +} // namespace boost + +#endif // BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/detected.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/detected.hpp new file mode 100644 index 00000000..96a38a2e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/detected.hpp @@ -0,0 +1,24 @@ +/* +Copyright 2017-2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_DETECTED_HPP_INCLUDED +#define BOOST_TT_DETECTED_HPP_INCLUDED + +#include +#include + +namespace boost { + +template class Op, class... Args> +using detected_t = typename + detail::detector::type; + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/detected_or.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/detected_or.hpp new file mode 100644 index 00000000..e79e02a6 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/detected_or.hpp @@ -0,0 +1,25 @@ +/* +Copyright 2017-2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_DETECTED_OR_HPP_INCLUDED +#define BOOST_TT_DETECTED_OR_HPP_INCLUDED + +#include + +namespace boost { + +template class Op, class... Args> +using detected_or = detail::detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/enable_if.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/enable_if.hpp new file mode 100644 index 00000000..3cdc2816 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/enable_if.hpp @@ -0,0 +1,37 @@ +/* +Copyright 2003 The Trustees of Indiana University + +Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) + Jeremiah Willcock (jewillco at osl.iu.edu) + Andrew Lumsdaine (lums at osl.iu.edu) + +Copyright 2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_ENABLE_IF_HPP_INCLUDED +#define BOOST_TT_ENABLE_IF_HPP_INCLUDED + +#include + +namespace boost { + +template +struct enable_if_ { + typedef T type; +}; + +template +struct enable_if_ { }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) +template +using enable_if_t = typename enable_if_::type; +#endif + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/extent.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/extent.hpp new file mode 100644 index 00000000..12425787 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/extent.hpp @@ -0,0 +1,139 @@ + +// (C) Copyright John Maddock 2005. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_EXTENT_HPP_INCLUDED +#define BOOST_TT_EXTENT_HPP_INCLUDED + +#include // size_t +#include +#include + +namespace boost { + +namespace detail{ + +#if defined( __CODEGEARC__ ) + // wrap the impl as main trait provides additional MPL lambda support + template < typename T, std::size_t N > + struct extent_imp { + static const std::size_t value = __array_extent(T, N); + }; + +#else + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = 0); +}; +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = R); +}; + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = R); +}; + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = R); +}; + +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = R); +}; + +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) && !defined(__MWERKS__) +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp::value)); +}; +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = 0); +}; +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = 0); +}; +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = 0); +}; +template +struct extent_imp +{ + BOOST_STATIC_CONSTANT(std::size_t, value = 0); +}; +#endif +#endif + +#endif // non-CodeGear implementation +} // ::boost::detail + +template +struct extent + : public ::boost::integral_constant::value> +{ +}; + +} // namespace boost + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/floating_point_promotion.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/floating_point_promotion.hpp new file mode 100644 index 00000000..9110f24a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/floating_point_promotion.hpp @@ -0,0 +1,28 @@ +// Copyright 2005 Alexander Nasonov. +// 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 FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED +#define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED + +#include + +namespace boost { + + template struct floating_point_promotion { typedef T type; }; + template<> struct floating_point_promotion { typedef double type; }; + template<> struct floating_point_promotion { typedef double const type; }; + template<> struct floating_point_promotion{ typedef double volatile type; }; + template<> struct floating_point_promotion { typedef double const volatile type; }; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using floating_point_promotion_t = typename floating_point_promotion::type; + +#endif + +} + +#endif // #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/function_traits.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/function_traits.hpp new file mode 100644 index 00000000..26d7e05c --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/function_traits.hpp @@ -0,0 +1,174 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED +#define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED + +#include +#include +#include + +namespace boost { + +namespace detail { + +template struct function_traits_helper; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 0); + typedef R result_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 1); + typedef R result_type; + typedef T1 arg1_type; + typedef T1 argument_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 2); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T1 first_argument_type; + typedef T2 second_argument_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 3); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 4); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 5); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 6); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 7); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 8); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; + typedef T8 arg8_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 9); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; + typedef T8 arg8_type; + typedef T9 arg9_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(unsigned, arity = 10); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; + typedef T8 arg8_type; + typedef T9 arg9_type; + typedef T10 arg10_type; +}; + +} // end namespace detail + +template +struct function_traits : + public boost::detail::function_traits_helper::type> +{ +}; + +} + +#endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_and.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_and.hpp new file mode 100644 index 00000000..a16c71a4 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_and.hpp @@ -0,0 +1,49 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_BIT_AND_HPP_INCLUDED +#define BOOST_TT_HAS_BIT_AND_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_bit_and +#define BOOST_TT_TRAIT_OP & +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_and_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_and_assign.hpp new file mode 100644 index 00000000..01e25e31 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_and_assign.hpp @@ -0,0 +1,55 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_BIT_AND_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_BIT_AND_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_bit_and_assign +#define BOOST_TT_TRAIT_OP &= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (\ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_or.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_or.hpp new file mode 100644 index 00000000..6e76929f --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_or.hpp @@ -0,0 +1,49 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_BIT_OR_HPP_INCLUDED +#define BOOST_TT_HAS_BIT_OR_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_bit_or +#define BOOST_TT_TRAIT_OP | +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_or_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_or_assign.hpp new file mode 100644 index 00000000..891c39c5 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_or_assign.hpp @@ -0,0 +1,55 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_BIT_OR_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_BIT_OR_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_bit_or_assign +#define BOOST_TT_TRAIT_OP |= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_xor.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_xor.hpp new file mode 100644 index 00000000..05173ac1 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_xor.hpp @@ -0,0 +1,49 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_BIT_XOR_HPP_INCLUDED +#define BOOST_TT_HAS_BIT_XOR_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_bit_xor +#define BOOST_TT_TRAIT_OP ^ +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_xor_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_xor_assign.hpp new file mode 100644 index 00000000..3866b7ac --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_bit_xor_assign.hpp @@ -0,0 +1,55 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_BIT_XOR_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_BIT_XOR_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_bit_xor_assign +#define BOOST_TT_TRAIT_OP ^= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_complement.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_complement.hpp new file mode 100644 index 00000000..d323e129 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_complement.hpp @@ -0,0 +1,32 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_COMPLEMENT_HPP_INCLUDED +#define BOOST_TT_HAS_COMPLEMENT_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_complement +#define BOOST_TT_TRAIT_OP ~ +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* pointer */\ + ::boost::is_pointer< Rhs_noref >::value || \ + /* fundamental non integral */\ + (\ + ::boost::is_fundamental< Rhs_noref >::value && \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_dereference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_dereference.hpp new file mode 100644 index 00000000..3275348b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_dereference.hpp @@ -0,0 +1,375 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_DEREFERENCE_HPP_INCLUDED +#define BOOST_TT_HAS_DEREFERENCE_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_dereference +#define BOOST_TT_TRAIT_OP * +#define BOOST_TT_FORBIDDEN_IF\ + /* void* or fundamental */\ + (\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_void< Rhs_noptr >::value\ + ) || \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + // references: + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + // rvalue refs: + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + template + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + template <> + struct has_dereference : public false_type {}; + + +} +#endif +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_divides.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_divides.hpp new file mode 100644 index 00000000..869e907f --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_divides.hpp @@ -0,0 +1,40 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_DIVIDES_HPP_INCLUDED +#define BOOST_TT_HAS_DIVIDES_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_divides +#define BOOST_TT_TRAIT_OP / +#define BOOST_TT_FORBIDDEN_IF\ + /* pointer with pointer or fundamental */\ + (\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + )||\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_divides_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_divides_assign.hpp new file mode 100644 index 00000000..1a8e3c1e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_divides_assign.hpp @@ -0,0 +1,47 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_DIVIDES_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_DIVIDES_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_divides_assign +#define BOOST_TT_TRAIT_OP /= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Lhs==const and Rhs==fundamental */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Lhs==pointer and (Rhs==fundamental or Rhs==pointer) */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + )||\ + /* Rhs==pointer and (Lhs==fundamental or Lhs==pointer) */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_equal_to.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_equal_to.hpp new file mode 100644 index 00000000..3405d340 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_equal_to.hpp @@ -0,0 +1,52 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_EQUAL_TO_HPP_INCLUDED +#define BOOST_TT_HAS_EQUAL_TO_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_equal_to +#define BOOST_TT_TRAIT_OP == +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==pointer and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value && \ + (! \ + (\ + ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \ + ::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_void< Lhs_noptr >::value || \ + ::boost::is_void< Rhs_noptr >::value\ + )\ + )\ + ) || \ + (\ + ::boost::type_traits_detail::is_likely_stateless_lambda::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_greater.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_greater.hpp new file mode 100644 index 00000000..1a9fda6f --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_greater.hpp @@ -0,0 +1,52 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_GREATER_HPP_INCLUDED +#define BOOST_TT_HAS_GREATER_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_greater +#define BOOST_TT_TRAIT_OP > +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==pointer and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value && \ + (! \ + ( \ + ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \ + ::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_void< Lhs_noptr >::value || \ + ::boost::is_void< Rhs_noptr >::value\ + )\ + )\ + ) || \ + (\ + ::boost::type_traits_detail::is_likely_stateless_lambda::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_greater_equal.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_greater_equal.hpp new file mode 100644 index 00000000..c87f0639 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_greater_equal.hpp @@ -0,0 +1,52 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_GREATER_EQUAL_HPP_INCLUDED +#define BOOST_TT_HAS_GREATER_EQUAL_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_greater_equal +#define BOOST_TT_TRAIT_OP >= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==pointer and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value && \ + (! \ + ( \ + ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \ + ::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_void< Lhs_noptr >::value || \ + ::boost::is_void< Rhs_noptr >::value\ + )\ + )\ + ) || \ + (\ + ::boost::type_traits_detail::is_likely_stateless_lambda::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_left_shift.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_left_shift.hpp new file mode 100644 index 00000000..e95c12a8 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_left_shift.hpp @@ -0,0 +1,49 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_LEFT_SHIFT_HPP_INCLUDED +#define BOOST_TT_HAS_LEFT_SHIFT_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_left_shift +#define BOOST_TT_TRAIT_OP << +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_left_shift_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_left_shift_assign.hpp new file mode 100644 index 00000000..74e0df95 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_left_shift_assign.hpp @@ -0,0 +1,55 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_LEFT_SHIFT_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_LEFT_SHIFT_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_left_shift_assign +#define BOOST_TT_TRAIT_OP <<= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_less.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_less.hpp new file mode 100644 index 00000000..1326a184 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_less.hpp @@ -0,0 +1,52 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_LESS_HPP_INCLUDED +#define BOOST_TT_HAS_LESS_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_less +#define BOOST_TT_TRAIT_OP < +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==pointer and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value && \ + (! \ + ( \ + ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \ + ::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_void< Lhs_noptr >::value || \ + ::boost::is_void< Rhs_noptr >::value\ + )\ + )\ + ) || \ + (\ + ::boost::type_traits_detail::is_likely_stateless_lambda::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_less_equal.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_less_equal.hpp new file mode 100644 index 00000000..607b71ce --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_less_equal.hpp @@ -0,0 +1,52 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_LESS_EQUAL_HPP_INCLUDED +#define BOOST_TT_HAS_LESS_EQUAL_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_less_equal +#define BOOST_TT_TRAIT_OP <= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==pointer and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value && \ + (! \ + ( \ + ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \ + ::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_void< Lhs_noptr >::value || \ + ::boost::is_void< Rhs_noptr >::value\ + )\ + )\ + ) || \ + (\ + ::boost::type_traits_detail::is_likely_stateless_lambda::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_and.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_and.hpp new file mode 100644 index 00000000..3bb1733d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_and.hpp @@ -0,0 +1,40 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_LOGICAL_AND_HPP_INCLUDED +#define BOOST_TT_HAS_LOGICAL_AND_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_logical_and +#define BOOST_TT_TRAIT_OP && +#define BOOST_TT_FORBIDDEN_IF\ + /* pointer with fundamental non convertible to bool */\ + (\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (! ::boost::is_convertible< Rhs_nocv, bool >::value )\ + )\ + )||\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Lhs_nocv >::value && \ + (! ::boost::is_convertible< Lhs_nocv, bool >::value )\ + )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_not.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_not.hpp new file mode 100644 index 00000000..d36858e1 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_not.hpp @@ -0,0 +1,32 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED +#define BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED + +#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" +#endif + +#define BOOST_TT_TRAIT_NAME has_logical_not +#define BOOST_TT_TRAIT_OP ! +#define BOOST_TT_FORBIDDEN_IF\ + false + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800) +#pragma GCC diagnostic pop +#endif + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_or.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_or.hpp new file mode 100644 index 00000000..a188726e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_logical_or.hpp @@ -0,0 +1,40 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_LOGICAL_OR_HPP_INCLUDED +#define BOOST_TT_HAS_LOGICAL_OR_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_logical_or +#define BOOST_TT_TRAIT_OP || +#define BOOST_TT_FORBIDDEN_IF\ + /* pointer with fundamental non convertible to bool */\ + (\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (! ::boost::is_convertible< Rhs_nocv, bool >::value )\ + )\ + )||\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + (! ::boost::is_convertible< Lhs_nocv, bool >::value )\ + )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_minus.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_minus.hpp new file mode 100644 index 00000000..fcd5d947 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_minus.hpp @@ -0,0 +1,158 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_MINUS_HPP_INCLUDED +#define BOOST_TT_HAS_MINUS_HPP_INCLUDED + +#include +#include + +// cannot include this header without getting warnings of the kind: +// gcc: +// warning: value computed is not used +// warning: comparison between signed and unsigned integer expressions +// msvc: +// warning C4018: '<' : signed/unsigned mismatch +// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data +// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect +// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) +// warning C4804: '<' : unsafe use of type 'bool' in operation +// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation +// cannot find another implementation -> declared as system header to suppress these warnings. +#if defined(__GNUC__) +# pragma GCC system_header +#elif defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) +# if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +# pragma warning ( disable : 6334) +# endif +#endif + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template + struct has_minus_ret_imp : public boost::false_type {}; + + template + struct has_minus_ret_imp::type>() - std::declval::type>())>::type> + : public boost::integral_constant::type>() - std::declval::type>()), Ret>::value> {}; + + template + struct has_minus_void_imp : public boost::false_type {}; + + template + struct has_minus_void_imp::type>() - std::declval::type>())>::type> + : public boost::integral_constant::type>() - std::declval::type>())>::value> {}; + + template + struct has_minus_dc_imp : public boost::false_type {}; + + template + struct has_minus_dc_imp::type>() - std::declval::type>())>::type> + : public boost::true_type {}; + + template + struct has_minus_ret_filter : public boost::binary_op_detail::has_minus_ret_imp {}; + template + struct has_minus_ret_filter : public boost::binary_op_detail::has_minus_void_imp {}; + template + struct has_minus_ret_filter : public boost::binary_op_detail::has_minus_dc_imp {}; + + template + struct has_minus_void_ptr_filter : public boost::binary_op_detail::has_minus_ret_filter {}; + template + struct has_minus_void_ptr_filter : public boost::false_type {}; + + } + + template + struct has_minus : + public boost::binary_op_detail::has_minus_void_ptr_filter< + T, U, Ret, + boost::is_void::type>::type>::value + || boost::is_void::type>::type>::value> {}; + + +} + +#else + + +#define BOOST_TT_TRAIT_NAME has_minus +#define BOOST_TT_TRAIT_OP - +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (! ::boost::is_integral< Rhs_noref >::value )\ + ) || \ + /* Lhs==void* and (Rhs==fundamental or Rhs==pointer) */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_void< Lhs_noptr >::value && \ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + ) || \ + /* Rhs==void* and (Lhs==fundamental or Lhs==pointer) */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_void< Rhs_noptr >::value && \ + (\ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + )\ + ) ||\ + /* Lhs=fundamental and Rhs=pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + ) ||\ + /* two different pointers */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value && \ + (! ::boost::is_same< Lhs_nocv, Rhs_nocv >::value )\ + )\ + ) + +#define BOOST_TT_FORBIDDEN_IF_NEW (boost::is_void::type>::type>::value || boost::is_void::type>::type>::value) + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_minus_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_minus_assign.hpp new file mode 100644 index 00000000..ea3169e0 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_minus_assign.hpp @@ -0,0 +1,163 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED +#define BOOST_TT_has_minus_assign_ASSIGN_HPP_INCLUDED + +#include +#include + +// cannot include this header without getting warnings of the kind: +// gcc: +// warning: value computed is not used +// warning: comparison between signed and unsigned integer expressions +// msvc: +// warning C4018: '<' : signed/unsigned mismatch +// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data +// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect +// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) +// warning C4804: '<' : unsafe use of type 'bool' in operation +// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation +// cannot find another implementation -> declared as system header to suppress these warnings. +#if defined(__GNUC__) +# pragma GCC system_header +#elif defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) +# if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +# pragma warning ( disable : 6334) +# endif +#endif + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template + struct has_minus_assign_ret_imp : public boost::false_type {}; + + template + struct has_minus_assign_ret_imp::type>() -= std::declval::type>())>::type> + : public boost::integral_constant::type>() -= std::declval::type>()), Ret>::value> {}; + + template + struct has_minus_assign_void_imp : public boost::false_type {}; + + template + struct has_minus_assign_void_imp::type>() -= std::declval::type>())>::type> + : public boost::integral_constant::type>() -= std::declval::type>())>::value> {}; + + template + struct has_minus_assign_dc_imp : public boost::false_type {}; + + template + struct has_minus_assign_dc_imp::type>() -= std::declval::type>())>::type> + : public boost::true_type {}; + + template + struct has_minus_assign_ret_filter : public boost::binary_op_detail::has_minus_assign_ret_imp {}; + template + struct has_minus_assign_ret_filter : public boost::binary_op_detail::has_minus_assign_void_imp {}; + template + struct has_minus_assign_ret_filter : public boost::binary_op_detail::has_minus_assign_dc_imp {}; + + template + struct has_minus_assign_void_ptr_filter : public boost::binary_op_detail::has_minus_assign_ret_filter {}; + template + struct has_minus_assign_void_ptr_filter : public boost::false_type {}; + + } + + template + struct has_minus_assign : + public boost::binary_op_detail::has_minus_assign_void_ptr_filter< + T, U, Ret, + boost::is_void::type>::type>::value + || boost::is_void::type>::type>::value + || (boost::is_pointer::type>::value && boost::is_pointer::type>::value)> {}; + + +} + +#else + +#define BOOST_TT_TRAIT_NAME has_minus_assign +#define BOOST_TT_TRAIT_OP -= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (! ::boost::is_integral< Rhs_noref >::value )\ + ) || \ + /* Lhs==void* and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_void< Lhs_noptr >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==void* and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_void< Rhs_noptr >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs=fundamental and Rhs=pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + ) || \ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + ) || \ + /* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\ + (\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + ) && \ + (\ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + ) && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_modulus.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_modulus.hpp new file mode 100644 index 00000000..24a815f3 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_modulus.hpp @@ -0,0 +1,49 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_MODULUS_HPP_INCLUDED +#define BOOST_TT_HAS_MODULUS_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_modulus +#define BOOST_TT_TRAIT_OP % +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (\ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_modulus_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_modulus_assign.hpp new file mode 100644 index 00000000..5e3e83fa --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_modulus_assign.hpp @@ -0,0 +1,55 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_MODULUS_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_MODULUS_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_modulus_assign +#define BOOST_TT_TRAIT_OP %= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_multiplies.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_multiplies.hpp new file mode 100644 index 00000000..591a0cea --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_multiplies.hpp @@ -0,0 +1,40 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_MULTIPLIES_HPP_INCLUDED +#define BOOST_TT_HAS_MULTIPLIES_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_multiplies +#define BOOST_TT_TRAIT_OP * +#define BOOST_TT_FORBIDDEN_IF\ + /* pointer with pointer or fundamental */\ + (\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + (\ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + )||\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + (\ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_multiplies_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_multiplies_assign.hpp new file mode 100644 index 00000000..b24f8794 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_multiplies_assign.hpp @@ -0,0 +1,47 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_MULTIPLIES_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_MULTIPLIES_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_multiplies_assign +#define BOOST_TT_TRAIT_OP *= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Lhs==const and Rhs==fundamental */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Lhs==pointer and (Rhs==fundamental or Rhs==pointer) */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + )||\ + /* Rhs==pointer and (Lhs==fundamental or Lhs==pointer) */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ( \ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_negate.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_negate.hpp new file mode 100644 index 00000000..452e54ab --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_negate.hpp @@ -0,0 +1,25 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NEGATE_HPP_INCLUDED +#define BOOST_TT_HAS_NEGATE_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_negate +#define BOOST_TT_TRAIT_OP - +#define BOOST_TT_FORBIDDEN_IF\ + /* pointer */\ + ::boost::is_pointer< Rhs_noref >::value + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_new_operator.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_new_operator.hpp new file mode 100644 index 00000000..4def872d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_new_operator.hpp @@ -0,0 +1,147 @@ + +// (C) Copyright Runar Undheim, Robert Ramey & 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED +#define BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED + +#include // std::nothrow_t +#include // std::size_t +#include +#include +#include + +#if defined(new) +# if BOOST_WORKAROUND(BOOST_MSVC, >= 1310) +# define BOOST_TT_AUX_MACRO_NEW_DEFINED +# pragma push_macro("new") +# undef new +# else +# error "Sorry but you can't include this header if 'new' is defined as a macro." +# endif +#endif + +namespace boost { +namespace detail { + template + struct test; + + template + struct has_new_operator_impl { + template + static type_traits::yes_type check_sig1( + U*, + test< + void *(*)(std::size_t), + &U::operator new + >* = NULL + ); + template + static type_traits::no_type check_sig1(...); + + template + static type_traits::yes_type check_sig2( + U*, + test< + void *(*)(std::size_t, const std::nothrow_t&), + &U::operator new + >* = NULL + ); + template + static type_traits::no_type check_sig2(...); + + template + static type_traits::yes_type check_sig3( + U*, + test< + void *(*)(std::size_t, void*), + &U::operator new + >* = NULL + ); + template + static type_traits::no_type check_sig3(...); + + + template + static type_traits::yes_type check_sig4( + U*, + test< + void *(*)(std::size_t), + &U::operator new[] + >* = NULL + ); + template + static type_traits::no_type check_sig4(...); + + template + static type_traits::yes_type check_sig5( + U*, + test< + void *(*)(std::size_t, const std::nothrow_t&), + &U::operator new[] + >* = NULL + ); + template + static type_traits::no_type check_sig5(...); + + template + static type_traits::yes_type check_sig6( + U*, + test< + void *(*)(std::size_t, void*), + &U::operator new[] + >* = NULL + ); + template + static type_traits::no_type check_sig6(...); + + // GCC2 won't even parse this template if we embed the computation + // of s1 in the computation of value. + #ifdef __GNUC__ + BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(has_new_operator_impl::template check_sig1(0))); + BOOST_STATIC_CONSTANT(unsigned, s2 = sizeof(has_new_operator_impl::template check_sig2(0))); + BOOST_STATIC_CONSTANT(unsigned, s3 = sizeof(has_new_operator_impl::template check_sig3(0))); + BOOST_STATIC_CONSTANT(unsigned, s4 = sizeof(has_new_operator_impl::template check_sig4(0))); + BOOST_STATIC_CONSTANT(unsigned, s5 = sizeof(has_new_operator_impl::template check_sig5(0))); + BOOST_STATIC_CONSTANT(unsigned, s6 = sizeof(has_new_operator_impl::template check_sig6(0))); + #else + #if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) + #pragma warning(push) + #pragma warning(disable:6334) + #endif + + BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(check_sig1(0))); + BOOST_STATIC_CONSTANT(unsigned, s2 = sizeof(check_sig2(0))); + BOOST_STATIC_CONSTANT(unsigned, s3 = sizeof(check_sig3(0))); + BOOST_STATIC_CONSTANT(unsigned, s4 = sizeof(check_sig4(0))); + BOOST_STATIC_CONSTANT(unsigned, s5 = sizeof(check_sig5(0))); + BOOST_STATIC_CONSTANT(unsigned, s6 = sizeof(check_sig6(0))); + + #if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) + #pragma warning(pop) + #endif + #endif + BOOST_STATIC_CONSTANT(bool, value = + (s1 == sizeof(type_traits::yes_type)) || + (s2 == sizeof(type_traits::yes_type)) || + (s3 == sizeof(type_traits::yes_type)) || + (s4 == sizeof(type_traits::yes_type)) || + (s5 == sizeof(type_traits::yes_type)) || + (s6 == sizeof(type_traits::yes_type)) + ); + }; +} // namespace detail + +template struct has_new_operator : public integral_constant::value>{}; + +} // namespace boost + +#if defined(BOOST_TT_AUX_MACRO_NEW_DEFINED) +# pragma pop_macro("new") +#endif + +#endif // BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_not_equal_to.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_not_equal_to.hpp new file mode 100644 index 00000000..5f2c39a4 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_not_equal_to.hpp @@ -0,0 +1,52 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOT_EQUAL_TO_HPP_INCLUDED +#define BOOST_TT_HAS_NOT_EQUAL_TO_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_not_equal_to +#define BOOST_TT_TRAIT_OP != +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==pointer and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value && \ + (! \ + (\ + ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \ + ::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \ + ::boost::is_void< Lhs_noptr >::value || \ + ::boost::is_void< Rhs_noptr >::value\ + )\ + )\ + ) || \ + (\ + ::boost::type_traits_detail::is_likely_stateless_lambda::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_assign.hpp new file mode 100644 index 00000000..7517fa80 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_assign.hpp @@ -0,0 +1,84 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED + +#include // size_t +#include +#include + +#if !defined(BOOST_HAS_NOTHROW_ASSIGN) || defined(BOOST_MSVC) || defined(BOOST_INTEL) +#include +#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include +#include +#include +#include +#include +#include +#include +#endif +#endif +#if defined(__GNUC__) || defined(__SUNPRO_CC) || defined(__clang__) +#include +#include +#include +#include +#ifdef BOOST_INTEL +#include +#endif +#endif + +namespace boost { + +#if !defined(BOOST_HAS_NOTHROW_ASSIGN) && !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + + namespace detail + { + template struct has_nothrow_assign_imp{ static const bool value = false; }; + template struct has_nothrow_assign_imp{ static const bool value = noexcept(boost::declval::type>() = boost::declval::type>()); }; + template struct has_nothrow_assign_imp{ static const bool value = has_nothrow_assign_imp::value; }; + template struct has_nothrow_assign_imp{ static const bool value = has_nothrow_assign_imp::value; }; + } + +#endif + + template + struct has_nothrow_assign : public integral_constant < bool, +#ifndef BOOST_HAS_NOTHROW_ASSIGN +#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + // Portable C++11 version: + detail::has_nothrow_assign_imp::type>::value || is_volatile::type>::value || is_reference::value), + is_assignable::type, typename add_reference::type>::value + >::value +#else + ::boost::has_trivial_assign::value +#endif +#else + BOOST_HAS_NOTHROW_ASSIGN(T) +#endif + > {}; + +template struct has_nothrow_assign : public has_nothrow_assign {}; +template <> struct has_nothrow_assign : public false_type{}; +template struct has_nothrow_assign : public false_type{}; +template struct has_nothrow_assign : public false_type{}; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +template struct has_nothrow_assign : public false_type{}; +#endif +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct has_nothrow_assign : public false_type{}; +template <> struct has_nothrow_assign : public false_type{}; +template <> struct has_nothrow_assign : public false_type{}; +#endif + +} // namespace boost + +#endif // BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_constructor.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_constructor.hpp new file mode 100644 index 00000000..fa47b1db --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_constructor.hpp @@ -0,0 +1,73 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED + +#include // size_t +#include +#include + +#ifdef BOOST_HAS_NOTHROW_CONSTRUCTOR + +#if defined(BOOST_MSVC) || defined(BOOST_INTEL) +#include +#endif +#if defined(__GNUC__ ) || defined(__SUNPRO_CC) || defined(__clang__) +#include +#endif + +namespace boost { + +template struct has_nothrow_constructor : public integral_constant{}; + +#elif !defined(BOOST_NO_CXX11_NOEXCEPT) + +#include +#include + +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4197) // top-level volatile in cast is ignored +#endif + +namespace boost { namespace detail{ + + template struct has_nothrow_constructor_imp : public boost::integral_constant{}; + template struct has_nothrow_constructor_imp : public boost::integral_constant{}; + template struct has_nothrow_constructor_imp : public has_nothrow_constructor_imp {}; +} + +template struct has_nothrow_constructor : public detail::has_nothrow_constructor_imp::value>{}; + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +#else + +#include + +namespace boost { + +template struct has_nothrow_constructor : public ::boost::has_trivial_constructor {}; + +#endif + +template<> struct has_nothrow_constructor : public false_type {}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template<> struct has_nothrow_constructor : public false_type{}; +template<> struct has_nothrow_constructor : public false_type{}; +template<> struct has_nothrow_constructor : public false_type{}; +#endif + +template struct has_nothrow_default_constructor : public has_nothrow_constructor{}; + +} // namespace boost + +#endif // BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_copy.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_copy.hpp new file mode 100644 index 00000000..0d9bb183 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_copy.hpp @@ -0,0 +1,82 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED + +#include +#include + +#ifdef BOOST_HAS_NOTHROW_COPY + +#if defined(BOOST_CLANG) || defined(__GNUC__) || defined(__ghs__) || defined(__CODEGEARC__) || defined(__SUNPRO_CC) +#include +#include +#include +#include +#ifdef BOOST_INTEL +#include +#endif +#elif defined(BOOST_MSVC) || defined(BOOST_INTEL) +#include +#include +#ifdef BOOST_INTEL +#include +#include +#endif +#endif + +namespace boost { + +template struct has_nothrow_copy_constructor : public integral_constant{}; + +#elif !defined(BOOST_NO_CXX11_NOEXCEPT) + +#include +#include + +namespace boost{ + +namespace detail{ + +template +struct has_nothrow_copy_constructor_imp : public boost::integral_constant{}; +template +struct has_nothrow_copy_constructor_imp : public boost::integral_constant()))>{}; + +} + +template struct has_nothrow_copy_constructor : public detail::has_nothrow_copy_constructor_imp::value>{}; + +#else + +#include + +namespace boost{ + +template struct has_nothrow_copy_constructor : public integral_constant::value>{}; + +#endif + +template <> struct has_nothrow_copy_constructor : public false_type{}; +template struct has_nothrow_copy_constructor : public false_type{}; +template struct has_nothrow_copy_constructor : public false_type{}; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +template struct has_nothrow_copy_constructor : public false_type{}; +#endif +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct has_nothrow_copy_constructor : public false_type{}; +template <> struct has_nothrow_copy_constructor : public false_type{}; +template <> struct has_nothrow_copy_constructor : public false_type{}; +#endif + +template struct has_nothrow_copy : public has_nothrow_copy_constructor{}; + +} // namespace boost + +#endif // BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_destructor.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_destructor.hpp new file mode 100644 index 00000000..74dd9e7e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_nothrow_destructor.hpp @@ -0,0 +1,56 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED + +#include + +#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(__SUNPRO_CC) && !(defined(BOOST_MSVC) && (_MSC_FULL_VER < 190023506)) + +#include +#include +#include +#include + +namespace boost{ + + namespace detail{ + + template + struct has_nothrow_destructor_imp : public boost::integral_constant{}; + template + struct has_nothrow_destructor_imp : public boost::integral_constant()->~T())>{}; + + } + + template struct has_nothrow_destructor : public detail::has_nothrow_destructor_imp::value> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to has_nothrow_destructor must be complete types"); + }; + template struct has_nothrow_destructor : public has_nothrow_destructor + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to has_nothrow_destructor must be complete types"); + }; + template struct has_nothrow_destructor : public integral_constant{}; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + template struct has_nothrow_destructor : public integral_constant{}; +#endif + template <> struct has_nothrow_destructor : public false_type {}; +} +#else + +namespace boost { + +template struct has_nothrow_destructor : public ::boost::has_trivial_destructor {}; + +} // namespace boost + +#endif + +#endif // BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_operator.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_operator.hpp new file mode 100644 index 00000000..c97a90fc --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_operator.hpp @@ -0,0 +1,51 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_OPERATOR_HPP_INCLUDED +#define BOOST_TT_HAS_OPERATOR_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_plus.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_plus.hpp new file mode 100644 index 00000000..2d793288 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_plus.hpp @@ -0,0 +1,54 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_PLUS_HPP_INCLUDED +#define BOOST_TT_HAS_PLUS_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_plus +#define BOOST_TT_TRAIT_OP + +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + ) || \ + /* Lhs==void* and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_void< Lhs_noptr >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==void* and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_void< Rhs_noptr >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (! ::boost::is_integral< Rhs_noref >::value )\ + ) || \ + /* Rhs==pointer and Lhs==fundamental and Lhs!=integral */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value && \ + (! ::boost::is_integral< Lhs_noref >::value )\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_plus_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_plus_assign.hpp new file mode 100644 index 00000000..161ca158 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_plus_assign.hpp @@ -0,0 +1,161 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED + +#include +#include + +// cannot include this header without getting warnings of the kind: +// gcc: +// warning: value computed is not used +// warning: comparison between signed and unsigned integer expressions +// msvc: +// warning C4018: '<' : signed/unsigned mismatch +// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data +// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect +// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) +// warning C4804: '<' : unsafe use of type 'bool' in operation +// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation +// cannot find another implementation -> declared as system header to suppress these warnings. +#if defined(__GNUC__) +# pragma GCC system_header +#elif defined(BOOST_MSVC) +# pragma warning ( push ) +# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) +# if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +# pragma warning ( disable : 6334) +# endif +#endif + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost +{ + + namespace binary_op_detail { + + struct dont_care; + + template + struct has_plus_assign_ret_imp : public boost::false_type {}; + + template + struct has_plus_assign_ret_imp::type>() += std::declval::type>())>::type> + : public boost::integral_constant::type>() += std::declval::type>()), Ret>::value> {}; + + template + struct has_plus_assign_void_imp : public boost::false_type {}; + + template + struct has_plus_assign_void_imp::type>() += std::declval::type>())>::type> + : public boost::integral_constant::type>() += std::declval::type>())>::value> {}; + + template + struct has_plus_assign_dc_imp : public boost::false_type {}; + + template + struct has_plus_assign_dc_imp::type>() += std::declval::type>())>::type> + : public boost::true_type {}; + + template + struct has_plus_assign_filter_ret : public boost::binary_op_detail:: has_plus_assign_ret_imp {}; + template + struct has_plus_assign_filter_ret : public boost::binary_op_detail:: has_plus_assign_void_imp {}; + template + struct has_plus_assign_filter_ret : public boost::binary_op_detail:: has_plus_assign_dc_imp {}; + + template + struct has_plus_assign_filter_impossible : public boost::binary_op_detail:: has_plus_assign_filter_ret {}; + template + struct has_plus_assign_filter_impossible : public boost::false_type {}; + + } + + template + struct has_plus_assign : public boost::binary_op_detail:: has_plus_assign_filter_impossible ::type>::value && boost::is_pointer::type>::value && !boost::is_same::type>::type>::value> {}; + +} + +#else + +#define BOOST_TT_TRAIT_NAME has_plus_assign +#define BOOST_TT_TRAIT_OP += +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + ) || \ + /* Lhs==void* and Rhs==fundamental */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_void< Lhs_noptr >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value\ + ) || \ + /* Rhs==void* and Lhs==fundamental */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_void< Rhs_noptr >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value\ + ) || \ + /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + (! ::boost::is_integral< Rhs_noref >::value )\ + ) || \ + /* Rhs==pointer and Lhs==fundamental and Lhs!=bool */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_fundamental< Lhs_nocv >::value && \ + (! ::boost::is_same< Lhs_nocv, bool >::value )\ + ) || \ + /* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\ + (\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + ) && \ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + ) && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif + +#if defined(BOOST_MSVC) +# pragma warning (pop) +#endif + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_post_decrement.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_post_decrement.hpp new file mode 100644 index 00000000..fc1c430a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_post_decrement.hpp @@ -0,0 +1,65 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED +#define BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED + +#include + +#define BOOST_TT_TRAIT_NAME has_post_decrement +#define BOOST_TT_TRAIT_OP -- +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* bool */\ + ::boost::is_same< bool, Lhs_nocv >::value || \ + /* void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_void< Lhs_noptr >::value\ + ) || \ + /* (fundamental or pointer) and const */\ + (\ + ( \ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + ) && \ + ::boost::is_const< Lhs_noref >::value\ + )||\ + /* Arrays */ \ + ::boost::is_array::value\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template + struct has_post_decrement : public false_type {}; + template <> + struct has_post_decrement : public false_type {}; + template <> + struct has_post_decrement : public false_type {}; + + template + struct has_post_decrement : public false_type {}; + template <> + struct has_post_decrement : public false_type {}; + template <> + struct has_post_decrement : public false_type {}; + +} + +#endif +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_post_increment.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_post_increment.hpp new file mode 100644 index 00000000..e83afd1c --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_post_increment.hpp @@ -0,0 +1,65 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED +#define BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED + +#include + +#define BOOST_TT_TRAIT_NAME has_post_increment +#define BOOST_TT_TRAIT_OP ++ +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* bool */\ + ::boost::is_same< bool, Lhs_nocv >::value || \ + /* void* */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_void< Lhs_noptr >::value\ + ) || \ + /* (fundamental or pointer) and const */\ + (\ + ( \ + ::boost::is_fundamental< Lhs_nocv >::value || \ + ::boost::is_pointer< Lhs_noref >::value\ + ) && \ + ::boost::is_const< Lhs_noref >::value\ + )||\ + /* Arrays */ \ + ::boost::is_array::value\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template + struct has_post_increment : public false_type {}; + template <> + struct has_post_increment : public false_type {}; + template <> + struct has_post_increment : public false_type {}; + + template + struct has_post_increment : public false_type {}; + template <> + struct has_post_increment : public false_type {}; + template <> + struct has_post_increment : public false_type {}; + +} + +#endif +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_pre_decrement.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_pre_decrement.hpp new file mode 100644 index 00000000..5ce50e90 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_pre_decrement.hpp @@ -0,0 +1,65 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_PRE_DECREMENT_HPP_INCLUDED +#define BOOST_TT_HAS_PRE_DECREMENT_HPP_INCLUDED + +#include + +#define BOOST_TT_TRAIT_NAME has_pre_decrement +#define BOOST_TT_TRAIT_OP -- +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* bool */\ + ::boost::is_same< bool, Rhs_nocv >::value || \ + /* void* */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_void< Rhs_noptr >::value\ + ) || \ + /* (fundamental or pointer) and const */\ + (\ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + ) && \ + ::boost::is_const< Rhs_noref >::value\ + )||\ + /* Arrays */ \ + ::boost::is_array::value\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template + struct has_pre_decrement : public false_type {}; + template <> + struct has_pre_decrement : public false_type {}; + template <> + struct has_pre_decrement : public false_type {}; + + template + struct has_pre_decrement : public false_type {}; + template <> + struct has_pre_decrement : public false_type {}; + template <> + struct has_pre_decrement : public false_type {}; + +} + +#endif +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_pre_increment.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_pre_increment.hpp new file mode 100644 index 00000000..9361cc8b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_pre_increment.hpp @@ -0,0 +1,66 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_PRE_INCREMENT_HPP_INCLUDED +#define BOOST_TT_HAS_PRE_INCREMENT_HPP_INCLUDED + +#include + +#define BOOST_TT_TRAIT_NAME has_pre_increment +#define BOOST_TT_TRAIT_OP ++ +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* bool */\ + ::boost::is_same< bool, Rhs_nocv >::value || \ + /* void* */\ + (\ + ::boost::is_pointer< Rhs_noref >::value && \ + ::boost::is_void< Rhs_noptr >::value\ + ) || \ + /* (fundamental or pointer) and const */\ + (\ + ( \ + ::boost::is_fundamental< Rhs_nocv >::value || \ + ::boost::is_pointer< Rhs_noref >::value\ + ) && \ + ::boost::is_const< Rhs_noref >::value\ + )||\ + /* Arrays */ \ + ::boost::is_array::value\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) + +namespace boost { + + template + struct has_pre_increment : public false_type {}; + template <> + struct has_pre_increment : public false_type {}; + template <> + struct has_pre_increment : public false_type {}; + + template + struct has_pre_increment : public false_type {}; + template <> + struct has_pre_increment : public false_type {}; + template <> + struct has_pre_increment : public false_type {}; + +} + +#endif + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_right_shift.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_right_shift.hpp new file mode 100644 index 00000000..55629112 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_right_shift.hpp @@ -0,0 +1,49 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_RIGHT_SHIFT_HPP_INCLUDED +#define BOOST_TT_HAS_RIGHT_SHIFT_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_right_shift +#define BOOST_TT_TRAIT_OP >> +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_right_shift_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_right_shift_assign.hpp new file mode 100644 index 00000000..0e2c2635 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_right_shift_assign.hpp @@ -0,0 +1,55 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_RIGHT_SHIFT_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_RIGHT_SHIFT_ASSIGN_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_right_shift_assign +#define BOOST_TT_TRAIT_OP >>= +#define BOOST_TT_FORBIDDEN_IF\ + (\ + /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ( \ + (! ::boost::is_integral< Lhs_noref >::value ) || \ + (! ::boost::is_integral< Rhs_noref >::value )\ + )\ + )||\ + /* Lhs==fundamental and Rhs==pointer */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Rhs==fundamental and Lhs==pointer */\ + (\ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_pointer< Lhs_noref >::value\ + )||\ + /* Lhs==pointer and Rhs==pointer */\ + (\ + ::boost::is_pointer< Lhs_noref >::value && \ + ::boost::is_pointer< Rhs_noref >::value\ + )||\ + /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\ + (\ + ::boost::is_fundamental< Lhs_nocv >::value && \ + ::boost::is_fundamental< Rhs_nocv >::value && \ + ::boost::is_const< Lhs_noref >::value\ + )\ + ) + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_assign.hpp new file mode 100644 index 00000000..15b917e7 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_assign.hpp @@ -0,0 +1,52 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED + +#include // size_t +#include +#include +#include + +#if !defined(BOOST_HAS_TRIVIAL_ASSIGN) || defined(BOOST_MSVC) || defined(__GNUC__) || defined(BOOST_INTEL) || defined(__SUNPRO_CC) || defined(__clang__) +#include +#include +#include +#include +#endif + +namespace boost { + + template + struct has_trivial_assign : public integral_constant < bool, +#ifdef BOOST_HAS_TRIVIAL_ASSIGN + BOOST_HAS_TRIVIAL_ASSIGN(T) +#else + ::boost::is_pod::value && !::boost::is_const::value && !::boost::is_volatile::value +#endif + > {}; + + template<> struct has_trivial_assign : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS + template<> struct has_trivial_assign : public false_type{}; + template<> struct has_trivial_assign : public false_type{}; + template<> struct has_trivial_assign : public false_type{}; +#endif + template struct has_trivial_assign : public false_type{}; + template struct has_trivial_assign : public false_type{}; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + template struct has_trivial_assign : public false_type{}; +#endif + // Arrays are not explictly assignable: + template struct has_trivial_assign : public false_type{}; + template struct has_trivial_assign : public false_type{}; + +} // namespace boost + +#endif // BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_constructor.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_constructor.hpp new file mode 100644 index 00000000..06c137d1 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_constructor.hpp @@ -0,0 +1,57 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED + +#include +#include +#include + +#ifdef BOOST_HAS_TRIVIAL_CONSTRUCTOR +#ifdef BOOST_HAS_SGI_TYPE_TRAITS +#include +#elif defined(__GNUC__) || defined(__SUNPRO_CC) +#include +#ifdef BOOST_INTEL +#include +#endif +#endif +#endif + + +#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || defined(BOOST_CLANG) || (defined(__SUNPRO_CC) && defined(BOOST_HAS_TRIVIAL_CONSTRUCTOR)) +#include +#define BOOST_TT_TRIVIAL_CONSTRUCT_FIX && is_default_constructible::value +#else +// +// Mot all compilers, particularly older GCC versions can handle the fix above. +#define BOOST_TT_TRIVIAL_CONSTRUCT_FIX +#endif + +namespace boost { + +template struct has_trivial_constructor +#ifdef BOOST_HAS_TRIVIAL_CONSTRUCTOR + : public integral_constant ::value || BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)) BOOST_TT_TRIVIAL_CONSTRUCT_FIX)>{}; +#else + : public integral_constant ::value>{}; +#endif + +template <> struct has_trivial_constructor : public boost::false_type{}; +template <> struct has_trivial_constructor : public boost::false_type{}; +template <> struct has_trivial_constructor : public boost::false_type{}; +template <> struct has_trivial_constructor : public boost::false_type{}; + +template struct has_trivial_default_constructor : public has_trivial_constructor {}; + +#undef BOOST_TT_TRIVIAL_CONSTRUCT_FIX + +} // namespace boost + +#endif // BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_copy.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_copy.hpp new file mode 100644 index 00000000..fd6ad2d0 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_copy.hpp @@ -0,0 +1,63 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED + +#include // size_t +#include +#include +#include + +#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || defined(BOOST_CLANG) || (defined(__SUNPRO_CC) && defined(BOOST_HAS_TRIVIAL_COPY)) +#include +#define BOOST_TT_TRIVIAL_CONSTRUCT_FIX && is_copy_constructible::value +#else +#define BOOST_TT_TRIVIAL_CONSTRUCT_FIX +#endif + +#ifdef BOOST_INTEL +#include +#include +#endif + +namespace boost { + +template struct has_trivial_copy +: public integral_constant::value +#endif +>{}; +// Arrays are not explicitly copyable: +template struct has_trivial_copy : public false_type{}; +template struct has_trivial_copy : public false_type{}; +// Are volatile types ever trivial? We don't really know, so assume not: +template struct has_trivial_copy : public false_type{}; + +template <> struct has_trivial_copy : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct has_trivial_copy : public false_type{}; +template <> struct has_trivial_copy : public false_type{}; +template <> struct has_trivial_copy : public false_type{}; +#endif + +template struct has_trivial_copy : public false_type{}; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +template struct has_trivial_copy : public false_type{}; +#endif + +template struct has_trivial_copy_constructor : public has_trivial_copy{}; + +#undef BOOST_TT_TRIVIAL_CONSTRUCT_FIX + +} // namespace boost + +#endif // BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_destructor.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_destructor.hpp new file mode 100644 index 00000000..9a3a61ff --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_destructor.hpp @@ -0,0 +1,48 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED + +#include +#include + +#ifdef BOOST_HAS_TRIVIAL_DESTRUCTOR + +#if defined(BOOST_INTEL) || defined(BOOST_MSVC) +#include +#endif +#ifdef BOOST_HAS_SGI_TYPE_TRAITS +#include +#endif + +#if defined(__GNUC__) || defined(__clang__) || defined(__SUNPRO_CC) +#include +#endif + +namespace boost { + +template struct has_trivial_destructor : public integral_constant{}; +#else +#include + +namespace boost{ + +template struct has_trivial_destructor : public integral_constant::value>{}; +#endif + +template <> struct has_trivial_destructor : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct has_trivial_destructor : public false_type{}; +template <> struct has_trivial_destructor : public false_type{}; +template <> struct has_trivial_destructor : public false_type{}; +#endif + +} // namespace boost + +#endif // BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_move_assign.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_move_assign.hpp new file mode 100644 index 00000000..7b392697 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_move_assign.hpp @@ -0,0 +1,73 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED + +#include // size_t +#include +#include + +#if !defined(BOOST_HAS_TRIVIAL_MOVE_ASSIGN) || defined(BOOST_MSVC) || defined(BOOST_INTEL) +#include +#include +#include +#ifdef BOOST_MSVC +#include +#endif +#endif + +#if defined(__GNUC__) || defined(__clang__) +#include +#include +#endif + +#ifdef __SUNPRO_CC +#include +#include +#if __cplusplus >= 201103 +#define SOLARIS_EXTRA_CHECK && is_assignable::type&, typename remove_const::type&&>::value +#endif +#endif + +#ifndef SOLARIS_EXTRA_CHECK +#define SOLARIS_EXTRA_CHECK +#endif + +namespace boost{ + +template +struct has_trivial_move_assign : public integral_constant::value && !::boost::is_const::value && !::boost::is_volatile::value SOLARIS_EXTRA_CHECK +#endif + > {}; + +template <> struct has_trivial_move_assign : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct has_trivial_move_assign : public false_type{}; +template <> struct has_trivial_move_assign : public false_type{}; +template <> struct has_trivial_move_assign : public false_type{}; +#endif +template struct has_trivial_move_assign : public false_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template struct has_trivial_move_assign : public false_type{}; +#endif +// Array types are not assignable: +template struct has_trivial_move_assign : public false_type{}; +template struct has_trivial_move_assign : public false_type{}; + +} // namespace boost + +#undef SOLARIS_EXTRA_CHECK + +#endif // BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_move_constructor.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_move_constructor.hpp new file mode 100644 index 00000000..ce85dc2d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_trivial_move_constructor.hpp @@ -0,0 +1,79 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED + +#include // size_t +#include +#include + +#ifdef BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR + +#if defined(BOOST_MSVC) || defined(BOOST_INTEL) +#include +#include +#include +#endif + +#if defined(__GNUC__) || defined(__clang__) +#include +#include +#endif + + +namespace boost { + +template struct has_trivial_move_constructor : public integral_constant{}; + +#else + +#ifdef __SUNPRO_CC +#include +#include +#if __cplusplus >= 201103 +#define SOLARIS_EXTRA_CHECK && is_constructible::type, typename remove_const::type&&>::value +#endif +#endif + +#ifndef SOLARIS_EXTRA_CHECK +#define SOLARIS_EXTRA_CHECK +#endif + +#include +#include + +namespace boost { + +template struct has_trivial_move_constructor + : public integral_constant::value && !::boost::is_volatile::value SOLARIS_EXTRA_CHECK>{}; + +#undef SOLARIS_EXTRA_CHECK + +#endif + +template <> struct has_trivial_move_constructor : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct has_trivial_move_constructor : public false_type{}; +template <> struct has_trivial_move_constructor : public false_type{}; +template <> struct has_trivial_move_constructor : public false_type{}; +#endif +// What should we do with reference types??? The standard seems to suggest these are trivial, even if the thing they reference is not: +template struct has_trivial_move_constructor : public true_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template struct has_trivial_move_constructor : public true_type{}; +#endif +// Arrays can not be explicitly copied: +template struct has_trivial_move_constructor : public false_type{}; +template struct has_trivial_move_constructor : public false_type{}; + +} // namespace boost + +#endif // BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_unary_minus.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_unary_minus.hpp new file mode 100644 index 00000000..6b3157f4 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_unary_minus.hpp @@ -0,0 +1,25 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_UNARY_MINUS_HPP_INCLUDED +#define BOOST_TT_HAS_UNARY_MINUS_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_unary_minus +#define BOOST_TT_TRAIT_OP - +#define BOOST_TT_FORBIDDEN_IF\ + /* pointer */\ + ::boost::is_pointer< Rhs_noref >::value + + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_unary_plus.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_unary_plus.hpp new file mode 100644 index 00000000..a61770f8 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_unary_plus.hpp @@ -0,0 +1,23 @@ +// (C) Copyright 2009-2011 Frederic Bron. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_HAS_UNARY_PLUS_HPP_INCLUDED +#define BOOST_TT_HAS_UNARY_PLUS_HPP_INCLUDED + +#define BOOST_TT_TRAIT_NAME has_unary_plus +#define BOOST_TT_TRAIT_OP + +#define BOOST_TT_FORBIDDEN_IF\ + false + +#include + +#undef BOOST_TT_TRAIT_NAME +#undef BOOST_TT_TRAIT_OP +#undef BOOST_TT_FORBIDDEN_IF + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_virtual_destructor.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_virtual_destructor.hpp new file mode 100644 index 00000000..4b0f3836 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/has_virtual_destructor.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright John Maddock 2005. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED + +#include +#include + +namespace boost { + +#ifdef BOOST_HAS_VIRTUAL_DESTRUCTOR + template struct has_virtual_destructor : public integral_constant{}; +#else + template struct has_virtual_destructor : public integral_constant{}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/ice.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/ice.hpp new file mode 100644 index 00000000..134bc4bb --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/ice.hpp @@ -0,0 +1,20 @@ + +// (C) Copyright John Maddock and Steve Cleary 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// macros and helpers for working with integral-constant-expressions. + +#ifndef BOOST_TT_ICE_HPP_INCLUDED +#define BOOST_TT_ICE_HPP_INCLUDED + +#include +#include +#include +#include +#include + +#endif // BOOST_TT_ICE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/integral_constant.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/integral_constant.hpp new file mode 100644 index 00000000..1b36dbd2 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/integral_constant.hpp @@ -0,0 +1,97 @@ +// (C) Copyright John Maddock 2015. +// 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_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP +#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP + +#include +#include + +#if (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ + || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ + || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ + || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ + || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) )\ + || defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) + + +namespace boost{ + namespace mpl + { + template struct bool_; + template struct integral_c; + struct integral_c_tag; + } +} + +#else + +namespace mpl_{ + + template struct bool_; + template struct integral_c; + struct integral_c_tag; +} + +namespace boost +{ + namespace mpl + { + using ::mpl_::bool_; + using ::mpl_::integral_c; + using ::mpl_::integral_c_tag; + } +} + +#endif + +namespace boost{ + + template + struct integral_constant + { + typedef mpl::integral_c_tag tag; + typedef T value_type; + typedef integral_constant type; + static const T value = val; + + operator const mpl::integral_c& ()const + { + static const char data[sizeof(long)] = { 0 }; + static const void* pdata = data; + return *(reinterpret_cast*>(pdata)); + } + BOOST_CONSTEXPR operator T()const { return val; } + }; + + template + T const integral_constant::value; + + template + struct integral_constant + { + typedef mpl::integral_c_tag tag; + typedef bool value_type; + typedef integral_constant type; + static const bool value = val; + + operator const mpl::bool_& ()const + { + static const char data[sizeof(long)] = { 0 }; + static const void* pdata = data; + return *(reinterpret_cast*>(pdata)); + } + BOOST_CONSTEXPR operator bool()const { return val; } + }; + + template + bool const integral_constant::value; + + typedef integral_constant true_type; + typedef integral_constant false_type; + +} + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/integral_promotion.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/integral_promotion.hpp new file mode 100644 index 00000000..526f90ca --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/integral_promotion.hpp @@ -0,0 +1,187 @@ +// Copyright 2005 Alexander Nasonov. +// 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 FILE_boost_type_traits_integral_promotion_hpp_INCLUDED +#define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED + +#include +#include +#include +#include +#include +#include + +namespace boost { + +namespace type_traits { namespace detail { + +// 4.5/2 +template struct need_promotion : public boost::is_enum {}; + +// 4.5/1 +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; +template<> struct need_promotion : public true_type {}; + + +// Specializations for non-standard types. +// Type is promoted if it's smaller then int. + +#define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(T) \ + template<> struct need_promotion \ + : public integral_constant {}; + +// Same set of integral types as in boost/type_traits/is_integral.hpp. +// Please, keep in sync. +#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ + || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) +// TODO: common macro for this #if. Or better yet, PP SEQ of non-standard types. +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int8 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int8 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int16 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int16) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int32 ) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int32) +#ifdef __BORLANDC__ +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int64) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64) +#endif +#endif + +#if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(boost::ulong_long_type) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(boost::long_long_type ) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(unsigned __int64) +BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64) +#endif + +#undef BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE + + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +// 4.5/2 +template<> struct need_promotion : public true_type {}; +#endif + +// 4.5/3 (integral bit-field) is not supported. + +// 4.5/4 +template<> struct need_promotion : public true_type {}; + + +// Get promoted type by index and cv qualifiers. + +template struct promote_from_index; + +#define BOOST_TT_AUX_PROMOTE_FROM_INDEX(N,T) \ + template<> struct promote_from_index { typedef T type; }; \ + template<> struct promote_from_index { typedef T volatile type; }; \ + template<> struct promote_from_index { typedef T const type; }; \ + template<> struct promote_from_index { typedef T const volatile type; }; + + +BOOST_TT_AUX_PROMOTE_FROM_INDEX(1, int ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(2, unsigned int ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(3, long ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(4, unsigned long) + + +// WARNING: integral promotions to non-standard types +// long long and __int64 are not defined by the standard. +// Additional specialisations and overloads shouldn't +// introduce ambiguity, though. + +#if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(5, boost::long_long_type ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(6, boost::ulong_long_type) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(7, __int64 ) +BOOST_TT_AUX_PROMOTE_FROM_INDEX(8, unsigned __int64) +#endif + +#undef BOOST_TT_AUX_PROMOTE_FROM_INDEX + + +// Define BOOST_TT_AUX_PROMOTED_INDEX_TESTER: +#if !defined(BOOST_MSVC) + +template +struct sized_type_for_promotion +{ + typedef char (&type)[N]; +}; + +#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I,T) \ + sized_type_for_promotion::type promoted_index_tester(T); + +#else + +#define BOOST_TT_AUX_PROMOTED_INDEX_TESTER(I,T) \ + char (&promoted_index_tester(T))[I]; + +#endif + +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(1, int ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(2, unsigned int ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(3, long ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(4, unsigned long) + +#if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(5, boost::long_long_type ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(6, boost::ulong_long_type) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(7, __int64 ) +BOOST_TT_AUX_PROMOTED_INDEX_TESTER(8, unsigned __int64) +#endif + +#undef BOOST_TT_AUX_PROMOTED_INDEX_TESTER + + +// Get an index of promoted type for type T. +// Precondition: need_promotion +template +struct promoted_index +{ + static T testee; // undefined + BOOST_STATIC_CONSTANT(int, value = sizeof(promoted_index_tester(+testee)) ); + // Unary plus promotes testee LOOK HERE ---> ^ +}; + +template +struct integral_promotion_impl +{ + typedef BOOST_DEDUCED_TYPENAME promote_from_index< + (boost::type_traits::detail::promoted_index::value) + , (boost::is_const::value) + , (boost::is_volatile::value) + >::type type; +}; + +template struct integral_promotion { typedef T type; }; +template struct integral_promotion : public integral_promotion_impl{}; + +} } + +template struct integral_promotion +{ +private: + typedef boost::type_traits::detail::need_promotion::type> tag_type; +public: + typedef typename boost::type_traits::detail::integral_promotion::type type; +}; + +#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) + + template using integral_promotion_t = typename integral_promotion::type; + +#endif + +} + +#endif // #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/intrinsics.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/intrinsics.hpp new file mode 100644 index 00000000..d41a61ec --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/intrinsics.hpp @@ -0,0 +1,391 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_INTRINSICS_HPP_INCLUDED +#define BOOST_TT_INTRINSICS_HPP_INCLUDED + +#ifndef BOOST_TT_DISABLE_INTRINSICS + +#include + +#ifndef BOOST_TT_CONFIG_HPP_INCLUDED +#include +#endif + +// +// Helper macros for builtin compiler support. +// If your compiler has builtin support for any of the following +// traits concepts, then redefine the appropriate macros to pick +// up on the compiler support: +// +// (these should largely ignore cv-qualifiers) +// BOOST_IS_UNION(T) should evaluate to true if T is a union type +// BOOST_IS_POD(T) should evaluate to true if T is a POD type +// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty class type (and not a union) +// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect +// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy +// BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy +// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy +// BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy +// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect +// BOOST_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw +// BOOST_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw +// BOOST_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw +// BOOST_HAS_VIRTUAL_DESTRUCTOR(T) should evaluate to true T has a virtual destructor +// BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) should evaluate to true if T has a non-throwing move constructor. +// BOOST_IS_NOTHROW_MOVE_ASSIGN(T) should evaluate to true if T has a non-throwing move assignment operator. +// +// The following can also be defined: when detected our implementation is greatly simplified. +// +// BOOST_IS_ABSTRACT(T) true if T is an abstract type +// BOOST_IS_BASE_OF(T,U) true if T is a base class of U +// BOOST_IS_CLASS(T) true if T is a class type (and not a union) +// BOOST_IS_CONVERTIBLE(T,U) true if T is convertible to U +// BOOST_IS_ENUM(T) true is T is an enum +// BOOST_IS_POLYMORPHIC(T) true if T is a polymorphic type +// BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T. +// +// define BOOST_TT_DISABLE_INTRINSICS to prevent any intrinsics being used (mostly used when testing) +// + +#ifdef BOOST_HAS_SGI_TYPE_TRAITS + // Hook into SGI's __type_traits class, this will pick up user supplied + // specializations as well as SGI - compiler supplied specializations. +# include +# ifdef __NetBSD__ + // There are two different versions of type_traits.h on NetBSD on Spark + // use an implicit include via algorithm instead, to make sure we get + // the same version as the std lib: +# include +# else +# include +# endif +# define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits::is_POD_type, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_default_constructor, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits::has_trivial_copy_constructor, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits::has_trivial_assignment_operator, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_destructor, ::__true_type>::value + +# ifdef __sgi +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +# endif +#endif + +#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) + // Metrowerks compiler is acquiring intrinsic type traits support + // post version 8. We hook into the published interface to pick up + // user defined specializations as well as compiler intrinsics as + // and when they become available: +# include +# define BOOST_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union::value +# define BOOST_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD::value +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor::value +# define BOOST_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor::value +# define BOOST_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment::value +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor::value +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\ + || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500)) +// +// Note that even though these intrinsics rely on other type traits classes +// we do not #include those here as it produces cyclic dependencies and +// can cause the intrinsics to not even be used at all! +// +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T)) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ( ::boost::is_pod::value && ! ::boost::is_const::value && !::boost::is_volatile::value)) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::is_pod::value) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::has_trivial_constructor::value) +#if !defined(BOOST_INTEL) +# define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) || ::boost::has_trivial_copy::value) && !is_array::value) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) || ::boost::is_pod::value) +#elif (_MSC_VER >= 1900) +# define BOOST_HAS_NOTHROW_COPY(T) ((__is_nothrow_constructible(T, typename add_lvalue_reference::type>::type)) && !is_array::value) +# define BOOST_HAS_TRIVIAL_COPY(T) (__is_trivially_constructible(T, typename add_lvalue_reference::type>::type)) +#endif +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::has_trivial_assign::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_CONVERTIBLE(T,U) ((__is_convertible_to(T,U) || (is_same::value && !is_function::value)) && !__is_abstract(U)) +# define BOOST_IS_ENUM(T) __is_enum(T) +// This one fails if the default alignment has been changed with /Zp: +// # define BOOST_ALIGNMENT_OF(T) __alignof(T) + +# if defined(_MSC_VER) && (_MSC_VER >= 1800) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__is_trivially_constructible(T, T&&) || boost::is_pod::value) && ! ::boost::is_volatile::value && ! ::boost::is_reference::value) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__is_trivially_assignable(T, T&&) || boost::is_pod::value) && ! ::boost::is_const::value && !::boost::is_volatile::value && ! ::boost::is_reference::value) +# elif defined(_MSC_VER) && (_MSC_VER >= 1700) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || boost::is_pod::value) && ! ::boost::is_volatile::value && ! ::boost::is_reference::value) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || boost::is_pod::value) && ! ::boost::is_const::value && !::boost::is_volatile::value && ! ::boost::is_reference::value) +# endif +#ifndef BOOST_NO_CXX11_FINAL +// This one doesn't quite always do the right thing on older VC++ versions +// we really need it when the final keyword is supported though: +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +#endif +#if _MSC_FULL_VER >= 180020827 +# define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&)) +# define BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&)) +#endif +#if _MSC_VER >= 1800 +# define BOOST_IS_FINAL(T) __is_final(T) +#endif +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__DMC__) && (__DMC__ >= 0x848) +// For Digital Mars C++, www.digitalmars.com +# define BOOST_IS_UNION(T) (__typeinfo(T) & 0x400) +# define BOOST_IS_POD(T) (__typeinfo(T) & 0x800) +# define BOOST_IS_EMPTY(T) (__typeinfo(T) & 0x1000) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__typeinfo(T) & 0x10) +# define BOOST_HAS_TRIVIAL_COPY(T) (__typeinfo(T) & 0x20) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__typeinfo(T) & 0x40) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__typeinfo(T) & 0x8) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__typeinfo(T) & 0x80) +# define BOOST_HAS_NOTHROW_COPY(T) (__typeinfo(T) & 0x100) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__typeinfo(T) & 0x200) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) (__typeinfo(T) & 0x4) +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(BOOST_CLANG) && defined(__has_feature) && !defined(__CUDACC__) +// +// Note that these intrinsics are disabled for the CUDA meta-compiler as it appears +// to not support them, even though the underlying clang compiler does so. +// This is a rubbish fix as it basically stops type traits from working correctly, +// but maybe the best we can do for now. See https://svn.boost.org/trac/boost/ticket/10694 +// +// +// Note that even though these intrinsics rely on other type traits classes +// we do not #include those here as it produces cyclic dependencies and +// can cause the intrinsics to not even be used at all! +// +# include + +# if __has_feature(is_union) +# define BOOST_IS_UNION(T) __is_union(T) +# endif +# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod) +# define BOOST_IS_POD(T) __is_pod(T) +# endif +# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# endif +# if __has_feature(has_trivial_constructor) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# endif +# if __has_feature(has_trivial_copy) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference::value) +# endif +# if __has_feature(has_trivial_assign) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile::value && is_assignable::value) +# endif +# if __has_feature(has_trivial_destructor) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) && is_destructible::value) +# endif +# if __has_feature(has_nothrow_constructor) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible::value) +# endif +# if __has_feature(has_nothrow_copy) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile::value && !is_reference::value && is_copy_constructible::value) +# endif +# if __has_feature(has_nothrow_assign) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile::value && is_assignable::value) +# endif +# if __has_feature(has_virtual_destructor) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) +# endif +# if __has_feature(is_abstract) +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# endif +# if __has_feature(is_base_of) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# endif +# if __has_feature(is_class) +# define BOOST_IS_CLASS(T) __is_class(T) +# endif +# if __has_feature(is_convertible_to) +# define BOOST_IS_CONVERTIBLE(T,U) __is_convertible_to(T,U) +# endif +# if __has_feature(is_enum) +# define BOOST_IS_ENUM(T) __is_enum(T) +# endif +# if __has_feature(is_polymorphic) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# endif +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +# if __has_extension(is_trivially_constructible) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible::value && !::boost::is_volatile::value) +# endif +# if __has_extension(is_trivially_assignable) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable::value && !::boost::is_volatile::value) +# endif +#endif +# if (!defined(unix) && !defined(__unix__)) || defined(__LP64__) || !defined(__GNUC__) +// GCC sometimes lies about alignment requirements +// of type double on 32-bit unix platforms, use the +// old implementation instead in that case: +# define BOOST_ALIGNMENT_OF(T) __alignof(T) +# endif +# if __has_feature(is_final) +# define BOOST_IS_FINAL(T) __is_final(T) +# endif + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG) +// +// Note that even though these intrinsics rely on other type traits classes +// we do not #include those here as it produces cyclic dependencies and +// can cause the intrinsics to not even be used at all! +// + +#ifdef BOOST_INTEL +# define BOOST_INTEL_TT_OPTS || is_pod::value +#else +# define BOOST_INTEL_TT_OPTS +#endif + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) __is_pod(T) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference::value) +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile::value && ! ::boost::is_const::value && is_assignable::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS && is_destructible::value) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible::value BOOST_INTEL_TT_OPTS) +# define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_reference::value && is_copy_constructible::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_const::value && is_assignable::value) +#else +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile::value && ! ::boost::is_const::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS) +#if ((__GNUC__ * 100 + __GNUC_MINOR__) != 407) && ((__GNUC__ * 100 + __GNUC_MINOR__) != 408) +# define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_reference::value && !is_array::value) +#endif +# define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile::value && !is_const::value && !is_array::value) +#endif +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_ENUM(T) __is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# if (!defined(unix) && !defined(__unix__) && \ + !(defined(__VXWORKS__) && defined(__i386__))) || defined(__LP64__) + // GCC sometimes lies about alignment requirements + // of type double on 32-bit unix platforms, use the + // old implementation instead in that case: +# define BOOST_ALIGNMENT_OF(T) __alignof__(T) +# endif +# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) +# define BOOST_IS_FINAL(T) __is_final(T) +# endif + +# if (__GNUC__ >= 5) && (__cplusplus >= 201103) +# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable::value && !::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible::value && !::boost::is_volatile::value) +# endif + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130) +# define BOOST_IS_UNION(T) __oracle_is_union(T) +# define BOOST_IS_POD(T) (__oracle_is_pod(T) && !is_function::value) +# define BOOST_IS_EMPTY(T) __oracle_is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__oracle_has_trivial_constructor(T) && ! ::boost::is_volatile::value) +# define BOOST_HAS_TRIVIAL_COPY(T) (__oracle_has_trivial_copy(T) && !is_reference::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && ! ::boost::is_volatile::value && ! ::boost::is_const::value && is_assignable::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__oracle_has_trivial_destructor(T) && is_destructible::value) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) ((__oracle_has_nothrow_constructor(T) || __oracle_has_trivial_constructor(T) || __oracle_is_trivial(T)) && is_default_constructible::value) +// __oracle_has_nothrow_copy appears to behave the same as __oracle_has_nothrow_assign, disabled for now: +//# define BOOST_HAS_NOTHROW_COPY(T) ((__oracle_has_nothrow_copy(T) || __oracle_has_trivial_copy(T) || __oracle_is_trivial(T)) && !is_volatile::value && !is_reference::value && is_copy_constructible::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) ((__oracle_has_nothrow_assign(T) || __oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && !is_volatile::value && !is_const::value && is_assignable::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __oracle_has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __oracle_is_abstract(T) +//# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __oracle_is_class(T) +# define BOOST_IS_ENUM(T) __oracle_is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __oracle_is_polymorphic(T) +# define BOOST_ALIGNMENT_OF(T) __alignof__(T) +# define BOOST_IS_FINAL(T) __oracle_is_final(T) + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) +# include +# include +# include + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) __is_pod(T) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile::value && !is_reference::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_ENUM(T) __is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# define BOOST_ALIGNMENT_OF(T) __alignof__(T) +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +# if defined(__CODEGEARC__) +# include +# include +# include +# include + +# define BOOST_IS_UNION(T) __is_union(T) +# define BOOST_IS_POD(T) __is_pod(T) +# define BOOST_IS_EMPTY(T) __is_empty(T) +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T)) +# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T) && !is_reference::value) +# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && !is_volatile::value) +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T)) +# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T)) +# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T) && !is_volatile::value && !is_reference::value) +# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile::value) +# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) + +# define BOOST_IS_ABSTRACT(T) __is_abstract(T) +# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_void::value && !is_void::value) +# define BOOST_IS_CLASS(T) __is_class(T) +# define BOOST_IS_CONVERTIBLE(T,U) (__is_convertible(T,U) || is_void::value) +# define BOOST_IS_ENUM(T) __is_enum(T) +# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T) +# define BOOST_ALIGNMENT_OF(T) alignof(T) + +# define BOOST_HAS_TYPE_TRAITS_INTRINSICS +#endif + +#endif // BOOST_TT_DISABLE_INTRINSICS + +#endif // BOOST_TT_INTRINSICS_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_abstract.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_abstract.hpp new file mode 100644 index 00000000..781d94a4 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_abstract.hpp @@ -0,0 +1,150 @@ +#ifndef BOOST_TT_IS_ABSTRACT_CLASS_HPP +#define BOOST_TT_IS_ABSTRACT_CLASS_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// is_abstract_class.hpp: +// +// (C) Copyright 2002 Rani Sharoni (rani_sharoni@hotmail.com) and Robert Ramey +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org for updates, documentation, and revision history. +// + +// Compile type discovery whether given type is abstract class or not. +// +// Requires DR 337 to be supported by compiler +// (http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#337). +// +// +// Believed (Jan 2004) to work on: +// - GCC 3.4 +// - VC++ 7.1 +// - compilers with new EDG frontend (Intel C++ 7, Comeau 4.3.2) +// +// Doesn't work on: +// - VC++6, VC++7.0 and less +// - GCC 3.3.X and less +// - Borland C++ 6 and less +// +// +// History: +// - Originally written by Rani Sharoni, see +// http://groups.google.com/groups?selm=df893da6.0207110613.75b2fe90%40posting.google.com +// At this time supported by EDG (Intel C++ 7, Comeau 4.3.2) and VC7.1. +// - Adapted and added into Boost.Serialization library by Robert Ramey +// (starting with submission #10). +// - Jan 2004: GCC 3.4 fixed to support DR337 (Giovanni Bajo). +// - Jan 2004: modified to be part of Boost.TypeTraits (Pavel Vozenilek). +// - Nov 2004: Christoph Ludwig found that the implementation did not work with +// template types and gcc-3.4 or VC7.1, fix due to Christoph Ludwig +// and John Maddock. +// - Dec 2004: Added new config macro BOOST_NO_IS_ABSTRACT which causes the template +// to degrade gracefully, rather than trash the compiler (John Maddock). +// + +#include // size_t +#include +#include +#ifndef BOOST_IS_ABSTRACT +#include +#include +#include +#ifdef BOOST_NO_IS_ABSTRACT +#include +#endif +#endif + +namespace boost { + +namespace detail{ + +#ifdef BOOST_IS_ABSTRACT +template +struct is_abstract_imp +{ + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_ABSTRACT(T)); +}; +#elif !defined(BOOST_NO_IS_ABSTRACT) +template +struct is_abstract_imp2 +{ + // Deduction fails if T is void, function type, + // reference type (14.8.2/2)or an abstract class type + // according to review status issue #337 + // + template + static type_traits::no_type check_sig(U (*)[1]); + template + static type_traits::yes_type check_sig(...); + // + // T must be a complete type, further if T is a template then + // it must be instantiated in order for us to get the right answer: + // + BOOST_STATIC_ASSERT(sizeof(T) != 0); + + // GCC2 won't even parse this template if we embed the computation + // of s1 in the computation of value. +#ifdef __GNUC__ + BOOST_STATIC_CONSTANT(std::size_t, s1 = sizeof(is_abstract_imp2::template check_sig(0))); +#else +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + BOOST_STATIC_CONSTANT(std::size_t, s1 = sizeof(check_sig(0))); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif +#endif + + BOOST_STATIC_CONSTANT(bool, value = + (s1 == sizeof(type_traits::yes_type))); +}; + +template +struct is_abstract_select +{ + template + struct rebind + { + typedef is_abstract_imp2 type; + }; +}; +template <> +struct is_abstract_select +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template +struct is_abstract_imp +{ + typedef is_abstract_select< ::boost::is_class::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type type; + + BOOST_STATIC_CONSTANT(bool, value = type::value); +}; + +#endif +} + +#ifndef BOOST_NO_IS_ABSTRACT +template struct is_abstract : public integral_constant::value> {}; +#else +template struct is_abstract : public integral_constant::value> {}; +#endif + +} // namespace boost + +#endif //BOOST_TT_IS_ABSTRACT_CLASS_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_arithmetic.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_arithmetic.hpp new file mode 100644 index 00000000..c23811eb --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_arithmetic.hpp @@ -0,0 +1,22 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED +#define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED + +#include +#include + +namespace boost { + +template +struct is_arithmetic : public integral_constant::value || is_floating_point::value> {}; + +} // namespace boost + +#endif // BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_array.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_array.hpp new file mode 100644 index 00000000..53e1613a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_array.hpp @@ -0,0 +1,43 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +// Some fixes for is_array are based on a newsgroup posting by Jonathan Lundquist. + + +#ifndef BOOST_TT_IS_ARRAY_HPP_INCLUDED +#define BOOST_TT_IS_ARRAY_HPP_INCLUDED + +#include +#include // size_t + +namespace boost { + +#if defined( __CODEGEARC__ ) + template struct is_array : public integral_constant {}; +#else + template struct is_array : public false_type {}; +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) + template struct is_array : public true_type {}; + template struct is_array : public true_type{}; + template struct is_array : public true_type{}; + template struct is_array : public true_type{}; +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + template struct is_array : public true_type{}; + template struct is_array : public true_type{}; + template struct is_array : public true_type{}; + template struct is_array : public true_type{}; +#endif +#endif + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_ARRAY_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_assignable.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_assignable.hpp new file mode 100644 index 00000000..6a9474b2 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_assignable.hpp @@ -0,0 +1,85 @@ + +// (C) Copyright John Maddock 2015. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED +#define BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED + +#include // size_t +#include +#include +#include +#include + +namespace boost{ + + template struct is_assignable; + +} + +#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) + +#include +#include + +namespace boost{ + + namespace detail{ + + struct is_assignable_imp + { + template() = boost::declval())> + static boost::type_traits::yes_type test(int); + + template + static boost::type_traits::no_type test(...); + }; + + } + + template struct is_assignable : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_assignable must be complete types"); + }; + template struct is_assignable : public is_assignable{}; + template struct is_assignable : public is_assignable{}; + template struct is_assignable : public is_assignable{}; + template struct is_assignable : public is_assignable{}; + template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant{}; + +#else + +#include +#include + +namespace boost{ + + // We don't know how to implement this: + template struct is_assignable : public integral_constant + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_assignable must be complete types"); + }; + template struct is_assignable : public integral_constant::value && is_pod::type>::value>{}; + template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant{}; + template struct is_assignable : public integral_constant{}; + /* + template <> struct is_assignable : public integral_constant{}; + template <> struct is_assignable : public integral_constant{}; + template <> struct is_assignable : public integral_constant{}; + template <> struct is_assignable : public integral_constant{}; + */ +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_and_derived.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_and_derived.hpp new file mode 100644 index 00000000..ee3dce59 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_and_derived.hpp @@ -0,0 +1,244 @@ + +// (C) Copyright Rani Sharoni 2003. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED +#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED + +#include +#include +#ifndef BOOST_IS_BASE_OF +#include +#include +#include +#include +#include +#endif +#include +#include + +namespace boost { + +namespace detail { + +#ifndef BOOST_IS_BASE_OF +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) \ + && !BOOST_WORKAROUND(__SUNPRO_CC , <= 0x540) \ + && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \ + && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) + + // The EDG version number is a lower estimate. + // It is not currently known which EDG version + // exactly fixes the problem. + +/************************************************************************* + +This version detects ambiguous base classes and private base classes +correctly, and was devised by Rani Sharoni. + +Explanation by Terje Slettebo and Rani Sharoni. + +Let's take the multiple base class below as an example, and the following +will also show why there's not a problem with private or ambiguous base +class: + +struct B {}; +struct B1 : B {}; +struct B2 : B {}; +struct D : private B1, private B2 {}; + +is_base_and_derived::value; + +First, some terminology: + +SC - Standard conversion +UDC - User-defined conversion + +A user-defined conversion sequence consists of an SC, followed by an UDC, +followed by another SC. Either SC may be the identity conversion. + +When passing the default-constructed Host object to the overloaded check_sig() +functions (initialization 8.5/14/4/3), we have several viable implicit +conversion sequences: + +For "static no_type check_sig(B const volatile *, int)" we have the conversion +sequences: + +C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC) +C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> + B const volatile* (SC - Conversion) + +For "static yes_type check_sig(D const volatile *, T)" we have the conversion +sequence: + +C -> D const volatile* (UDC) + +According to 13.3.3.1/4, in context of user-defined conversion only the +standard conversion sequence is considered when selecting the best viable +function, so it only considers up to the user-defined conversion. For the +first function this means choosing between C -> C const and C -> C, and it +chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the +former. Therefore, we have: + +C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> + B const volatile* (SC - Conversion) +C -> D const volatile* (UDC) + +Here, the principle of the "shortest subsequence" applies again, and it +chooses C -> D const volatile*. This shows that it doesn't even need to +consider the multiple paths to B, or accessibility, as that possibility is +eliminated before it could possibly cause ambiguity or access violation. + +If D is not derived from B, it has to choose between C -> C const -> B const +volatile* for the first function, and C -> D const volatile* for the second +function, which are just as good (both requires a UDC, 13.3.3.2), had it not +been for the fact that "static no_type check_sig(B const volatile *, int)" is +not templated, which makes C -> C const -> B const volatile* the best choice +(13.3.3/1/4), resulting in "no". + +Also, if Host::operator B const volatile* hadn't been const, the two +conversion sequences for "static no_type check_sig(B const volatile *, int)", in +the case where D is derived from B, would have been ambiguous. + +See also +http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting. +google.com and links therein. + +*************************************************************************/ + +template +struct bd_helper +{ + // + // This VC7.1 specific workaround stops the compiler from generating + // an internal compiler error when compiling with /vmg (thanks to + // Aleksey Gurtovoy for figuring out the workaround). + // +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) + template + static type_traits::yes_type check_sig(D const volatile *, T); + static type_traits::no_type check_sig(B const volatile *, int); +#else + static type_traits::yes_type check_sig(D const volatile *, long); + static type_traits::no_type check_sig(B const volatile * const&, int); +#endif +}; + +template +struct is_base_and_derived_impl2 +{ +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(push) +#pragma warning(disable:6334) +#endif + // + // May silently do the wrong thing with incomplete types + // unless we trap them here: + // + BOOST_STATIC_ASSERT(sizeof(B) != 0); + BOOST_STATIC_ASSERT(sizeof(D) != 0); + + struct Host + { +#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) + operator B const volatile *() const; +#else + operator B const volatile * const&() const; +#endif + operator D const volatile *(); + }; + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(bd_helper::check_sig(Host(), 0)) == sizeof(type_traits::yes_type)); +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(pop) +#endif +}; + +#else + +// +// broken version: +// +template +struct is_base_and_derived_impl2 +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::is_convertible::value)); +}; + +#define BOOST_BROKEN_IS_BASE_AND_DERIVED + +#endif + +template +struct is_base_and_derived_impl3 +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct is_base_and_derived_select +{ + template + struct rebind + { + typedef is_base_and_derived_impl3 type; + }; +}; + +template <> +struct is_base_and_derived_select +{ + template + struct rebind + { + typedef is_base_and_derived_impl2 type; + }; +}; + +template +struct is_base_and_derived_impl +{ + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + + typedef is_base_and_derived_select< + ::boost::is_class::value, + ::boost::is_class::value, + ::boost::is_same::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type bound_type; + + BOOST_STATIC_CONSTANT(bool, value = bound_type::value); +}; +#else +template +struct is_base_and_derived_impl +{ + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + + BOOST_STATIC_CONSTANT(bool, value = (BOOST_IS_BASE_OF(B,D) && ! ::boost::is_same::value)); +}; +#endif +} // namespace detail + +template struct is_base_and_derived + : public integral_constant::value)> {}; + +template struct is_base_and_derived : public false_type{}; +template struct is_base_and_derived : public false_type{}; +template struct is_base_and_derived : public false_type{}; + +#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) +template struct is_base_and_derived : public true_type{}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_of.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_of.hpp new file mode 100644 index 00000000..89f2f679 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_of.hpp @@ -0,0 +1,39 @@ + +// (C) Copyright Rani Sharoni 2003-2005. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_BASE_OF_HPP_INCLUDED +#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED + +#include +#include +#include + +namespace boost { + + namespace detail{ + template + struct is_base_of_imp + { + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + BOOST_STATIC_CONSTANT(bool, value = ( + (::boost::detail::is_base_and_derived_impl::value) || + (::boost::is_same::value && ::boost::is_class::value))); + }; + } + + template struct is_base_of + : public integral_constant::value)> {}; + + template struct is_base_of : false_type{}; + template struct is_base_of : false_type{}; + template struct is_base_of : false_type{}; + +} // namespace boost + +#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_of_tr1.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_of_tr1.hpp new file mode 100644 index 00000000..210bf54e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_base_of_tr1.hpp @@ -0,0 +1,37 @@ + +// (C) Copyright Rani Sharoni 2003-2005. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_BASE_OF_TR1_HPP_INCLUDED +#define BOOST_TT_IS_BASE_OF_TR1_HPP_INCLUDED + +#include +#include +#include + +namespace boost { namespace tr1{ + + namespace detail{ + template + struct is_base_of_imp + { + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + BOOST_STATIC_CONSTANT(bool, value = ((::boost::detail::is_base_and_derived_impl::value) || (::boost::is_same::value))); + }; + } + + template struct is_base_of + : public integral_constant::value)>{}; + + template struct is_base_of : public false_type{}; + template struct is_base_of : public false_type{}; + template struct is_base_of : public false_type{}; + +} } // namespace boost + +#endif // BOOST_TT_IS_BASE_OF_TR1_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_bounded_array.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_bounded_array.hpp new file mode 100644 index 00000000..5aeca6f9 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_bounded_array.hpp @@ -0,0 +1,42 @@ +/* +Copyright 2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_IS_BOUNDED_ARRAY_HPP_INCLUDED +#define BOOST_TT_IS_BOUNDED_ARRAY_HPP_INCLUDED + +#include +#include + +namespace boost { + +template +struct is_bounded_array + : false_type { }; + +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +template +struct is_bounded_array + : true_type { }; + +template +struct is_bounded_array + : true_type { }; + +template +struct is_bounded_array + : true_type { }; + +template +struct is_bounded_array + : true_type { }; +#endif + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_class.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_class.hpp new file mode 100644 index 00000000..e3a22d2b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_class.hpp @@ -0,0 +1,114 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000-2003. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_CLASS_HPP_INCLUDED +#define BOOST_TT_IS_CLASS_HPP_INCLUDED + +#include +#include +#include +#ifndef BOOST_IS_CLASS +# include + +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION +# include +#else +# include +# include +# include +# include +# include +#endif + +#endif // BOOST_IS_CLASS + +namespace boost { + +namespace detail { + +#ifndef BOOST_IS_CLASS +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + +// This is actually the conforming implementation which works with +// abstract classes. However, enough compilers have trouble with +// it that most will use the one in +// boost/type_traits/object_traits.hpp. This implementation +// actually works with VC7.0, but other interactions seem to fail +// when we use it. + +// is_class<> metafunction due to Paul Mensonides +// (leavings@attbi.com). For more details: +// http://groups.google.com/groups?hl=en&selm=000001c1cc83%24e154d5e0%247772e50c%40c161550a&rnum=1 +#if defined(__GNUC__) && !defined(__EDG_VERSION__) + +template ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); +template ::boost::type_traits::no_type is_class_tester(...); + +template +struct is_class_impl +{ + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(is_class_tester(0)) == sizeof(::boost::type_traits::yes_type) + && ! ::boost::is_union::value + ); +}; + +#else + +template +struct is_class_impl +{ + template static ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); + template static ::boost::type_traits::no_type is_class_tester(...); + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(is_class_tester(0)) == sizeof(::boost::type_traits::yes_type) + && ! ::boost::is_union::value + ); +}; + +#endif + +#else + +template +struct is_class_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + ! ::boost::is_union::value >::value + && ! ::boost::is_scalar::value + && ! ::boost::is_array::value + && ! ::boost::is_reference::value + && ! ::boost::is_void::value + && ! ::boost::is_function::value + ); +}; + +# endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION +# else // BOOST_IS_CLASS +template +struct is_class_impl +{ + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_CLASS(T)); +}; +# endif // BOOST_IS_CLASS + +} // namespace detail + +template struct is_class : public integral_constant::value> {}; +# ifdef __EDG_VERSION__ +template struct is_class : public is_class{}; +template struct is_class : public is_class{}; +template struct is_class : public is_class{}; +# endif + +} // namespace boost + +#endif // BOOST_TT_IS_CLASS_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_complete.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_complete.hpp new file mode 100644 index 00000000..07cb8974 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_complete.hpp @@ -0,0 +1,92 @@ + +// (C) Copyright John Maddock 2017. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_COMPLETE_HPP_INCLUDED +#define BOOST_TT_IS_COMPLETE_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +/* + * CAUTION: + * ~~~~~~~~ + * + * THIS TRAIT EXISTS SOLELY TO GENERATE HARD ERRORS WHEN A ANOTHER TRAIT + * WHICH REQUIRES COMPLETE TYPES AS ARGUMENTS IS PASSED AN INCOMPLETE TYPE + * + * DO NOT MAKE GENERAL USE OF THIS TRAIT, AS THE COMPLETENESS OF A TYPE + * VARIES ACROSS TRANSLATION UNITS AS WELL AS WITHIN A SINGLE UNIT. + * +*/ + +namespace boost { + + +// +// We will undef this if the trait isn't fully functional: +// +#define BOOST_TT_HAS_WORKING_IS_COMPLETE + +#if !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40600) + + namespace detail{ + + template + struct ok_tag { double d; char c[N]; }; + + template + ok_tag check_is_complete(int); + template + char check_is_complete(...); + } + + template struct is_complete + : public integral_constant::type>::value || (sizeof(boost::detail::check_is_complete(0)) != sizeof(char))> {}; + +#elif !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) + + namespace detail + { + + template + struct is_complete_imp + { + template ())) > + static type_traits::yes_type check(U*); + + template + static type_traits::no_type check(...); + + static const bool value = sizeof(check(0)) == sizeof(type_traits::yes_type); + }; + +} // namespace detail + + + template + struct is_complete : boost::integral_constant::type>::value || ::boost::detail::is_complete_imp::value> + {}; + template + struct is_complete : boost::is_complete {}; + +#else + + template struct is_complete + : public boost::integral_constant {}; + +#undef BOOST_TT_HAS_WORKING_IS_COMPLETE + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_COMPLETE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_complex.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_complex.hpp new file mode 100644 index 00000000..c4554cea --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_complex.hpp @@ -0,0 +1,25 @@ +// (C) Copyright John Maddock 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_COMPLEX_HPP +#define BOOST_TT_IS_COMPLEX_HPP + +#include +#include +#include + +namespace boost { + + template struct is_complex : public false_type {}; + template struct is_complex : public is_complex{}; + template struct is_complex : public is_complex{}; + template struct is_complex : public is_complex{}; + template struct is_complex > : public true_type{}; + +} // namespace boost + +#endif //BOOST_TT_IS_COMPLEX_HPP diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_compound.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_compound.hpp new file mode 100644 index 00000000..7995eb8a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_compound.hpp @@ -0,0 +1,24 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_COMPOUND_HPP_INCLUDED +#define BOOST_TT_IS_COMPOUND_HPP_INCLUDED + +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) + template struct is_compound : public integral_constant {}; +#else + template struct is_compound : public integral_constant::value> {}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_COMPOUND_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_const.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_const.hpp new file mode 100644 index 00000000..e0ed88a3 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_const.hpp @@ -0,0 +1,47 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_CONST_HPP_INCLUDED +#define BOOST_TT_IS_CONST_HPP_INCLUDED + +#include // size_t +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) + + template + struct is_const : public integral_constant {}; + +#else + + template + struct is_const : public false_type {}; + template struct is_const : public true_type{}; + template struct is_const : public true_type{}; + template struct is_const : public true_type{}; + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_CONST_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_constructible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_constructible.hpp new file mode 100644 index 00000000..6969cd63 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_constructible.hpp @@ -0,0 +1,90 @@ + +// (C) Copyright John Maddock 2015. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_CONSTRUCTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_CONSTRUCTIBLE_HPP_INCLUDED + +#include +#include + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) + +#include +#include +#include +#include +#include +#include + +#define BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING 1 + +namespace boost{ + + namespace detail{ + + struct is_constructible_imp + { + template()...))> + static boost::type_traits::yes_type test(int); + template + static boost::type_traits::no_type test(...); + + template()))> + static boost::type_traits::yes_type test1(int); + template + static boost::type_traits::no_type test1(...); + + template + static boost::type_traits::yes_type ref_test(T); + template + static boost::type_traits::no_type ref_test(...); + }; + + } + + template struct is_constructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(::boost::is_complete::value, "The target type must be complete in order to test for constructibility"); + }; + template struct is_constructible : public integral_constant::value && sizeof(boost::detail::is_constructible_imp::test1(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(::boost::is_complete::value, "The target type must be complete in order to test for constructibility"); + }; + template struct is_constructible : public integral_constant(boost::declval())) == sizeof(boost::type_traits::yes_type)>{}; + template struct is_constructible : public integral_constant(boost::declval())) == sizeof(boost::type_traits::yes_type)>{}; + + template <> struct is_constructible : public false_type{}; + template <> struct is_constructible : public false_type{}; + template <> struct is_constructible : public false_type{}; + template <> struct is_constructible : public false_type{}; + + template struct is_constructible : public is_default_constructible{}; + +#else + +#include +#include + +namespace boost{ + + // We don't know how to implement this: + template struct is_constructible : public is_convertible{}; + template struct is_constructible : public is_default_constructible{}; + template <> struct is_constructible : public false_type{}; + template <> struct is_constructible : public false_type{}; + template <> struct is_constructible : public false_type{}; + template <> struct is_constructible : public false_type{}; + template struct is_constructible : public false_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + template struct is_constructible : public false_type{}; +#endif +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_CONSTRUCTIBLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_convertible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_convertible.hpp new file mode 100644 index 00000000..bf648fc4 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_convertible.hpp @@ -0,0 +1,506 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu) +// Copyright 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#ifndef BOOST_IS_CONVERTIBLE +#include +#include +#include +#include +#include +#if !defined(BOOST_NO_IS_ABSTRACT) +#include +#endif +#include +#include +#include + +#if defined(__MWERKS__) +#include +#endif +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +# include +#endif +#elif defined(BOOST_MSVC) || defined(BOOST_INTEL) +#include +#include +#endif // BOOST_IS_CONVERTIBLE + +namespace boost { + +#ifndef BOOST_IS_CONVERTIBLE + +// is one type convertible to another? +// +// there are multiple versions of the is_convertible +// template, almost every compiler seems to require its +// own version. +// +// Thanks to Andrei Alexandrescu for the original version of the +// conversion detection technique! +// + +namespace detail { + +#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !(defined(BOOST_GCC) && (BOOST_GCC < 40700)) + + // This is a C++11 conforming version, place this first and use it wherever possible: + +# define BOOST_TT_CXX11_IS_CONVERTIBLE + + template + struct or_helper + { + static const bool value = (A::value || B::value || C::value); + }; + + template, boost::is_function, boost::is_array >::value> + struct is_convertible_basic_impl + { + // Nothing converts to function or array, but void converts to void: + static const bool value = is_void::value; + }; + + template + class is_convertible_basic_impl + { + typedef char one; + typedef int two; + + template + static void test_aux(To1); + + template + static decltype(test_aux(boost::declval()), one()) test(int); + + template + static two test(...); + + public: + static const bool value = sizeof(test(0)) == 1; + }; + +#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560) +// +// special version for Borland compilers +// this version breaks when used for some +// UDT conversions: +// +template +struct is_convertible_impl +{ +#pragma option push -w-8074 + // This workaround for Borland breaks the EDG C++ frontend, + // so we only use it for Borland. + template struct checker + { + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(T); + }; + + static typename add_lvalue_reference::type _m_from; + static bool const value = sizeof( checker::_m_check(_m_from) ) + == sizeof(::boost::type_traits::yes_type); +#pragma option pop +}; + +#elif defined(__GNUC__) || defined(__BORLANDC__) && (__BORLANDC__ < 0x600) +// special version for gcc compiler + recent Borland versions +// note that this does not pass UDT's through (...) + +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + template any_conversion(T&); +}; + +template struct checker +{ + static boost::type_traits::no_type _m_check(any_conversion ...); + static boost::type_traits::yes_type _m_check(T, int); +}; + +template +struct is_convertible_basic_impl +{ + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))) + static bool const value = + sizeof( boost::detail::checker::_m_check(static_cast(_m_from), 0) ) + == sizeof(::boost::type_traits::yes_type); +#else + static bool const value = + sizeof( boost::detail::checker::_m_check(_m_from, 0) ) + == sizeof(::boost::type_traits::yes_type); +#endif +}; + +#elif (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 245) && !defined(__ICL)) \ + || defined(__IBMCPP__) || defined(__HP_aCC) +// +// This is *almost* an ideal world implementation as it doesn't rely +// on undefined behaviour by passing UDT's through (...). +// Unfortunately it doesn't quite pass all the tests for most compilers (sigh...) +// Enable this for your compiler if is_convertible_test.cpp will compile it... +// +// Note we do not enable this for VC7.1, because even though it passes all the +// type_traits tests it is known to cause problems when instantiation occurs +// deep within the instantiation tree :-( +// +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + // we need this constructor to catch references to functions + // (which can not be cv-qualified): + template any_conversion(T&); +}; + +template +struct is_convertible_basic_impl +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from), 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +}; + +#elif defined(__DMC__) + +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + // we need this constructor to catch references to functions + // (which can not be cv-qualified): + template any_conversion(T&); +}; + +template +struct is_convertible_basic_impl +{ + // Using '...' doesn't always work on Digital Mars. This version seems to. + template + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion, float, T); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int, int); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; + + // Static constants sometime cause the conversion of _m_from to To to be + // called. This doesn't happen with an enum. +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + enum { value = + sizeof( _m_check(static_cast(_m_from), 0, 0) ) == sizeof(::boost::type_traits::yes_type) + }; +#else + enum { value = + sizeof( _m_check(_m_from, 0, 0) ) == sizeof(::boost::type_traits::yes_type) + }; +#endif +}; + +#elif defined(__MWERKS__) +// +// CW works with the technique implemented above for EDG, except when From +// is a function type (or a reference to such a type), in which case +// any_conversion won't be accepted as a valid conversion. We detect this +// exceptional situation and channel it through an alternative algorithm. +// + +template +struct is_convertible_basic_impl_aux; + +struct any_conversion +{ + template any_conversion(const volatile T&); + template any_conversion(const T&); + template any_conversion(volatile T&); + template any_conversion(T&); +}; + +template +struct is_convertible_basic_impl_aux +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from), 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +}; + +template +struct is_convertible_basic_impl_aux +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To); + typedef typename add_lvalue_reference::type lvalue_type; + typedef typename add_rvalue_reference::type rvalue_type; + static lvalue_type _m_from; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from)) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +}; + +template +struct is_convertible_basic_impl: + is_convertible_basic_impl_aux< + From,To, + ::boost::is_function::type>::value + > +{}; + +#else +// +// This version seems to work pretty well for a wide spectrum of compilers, +// however it does rely on undefined behaviour by passing UDT's through (...). +// + +//Workaround for old compilers like MSVC 7.1 to avoid +//forming a reference to an array of unknown bound +template +struct is_convertible_basic_impl_add_lvalue_reference + : add_lvalue_reference +{}; + +template +struct is_convertible_basic_impl_add_lvalue_reference +{ + typedef From type []; +}; + +template +struct is_convertible_basic_impl +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To); + typedef typename is_convertible_basic_impl_add_lvalue_reference::type lvalue_type; + static lvalue_type _m_from; +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4244) +#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) +#pragma warning(disable:6334) +#endif +#endif +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + typedef typename add_rvalue_reference::type rvalue_type; + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(static_cast(_m_from)) ) == sizeof(::boost::type_traits::yes_type) + ); +#else + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type) + ); +#endif +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif +}; + +#endif // is_convertible_impl + +#if defined(__DMC__) +// As before, a static constant sometimes causes errors on Digital Mars. +template +struct is_convertible_impl +{ + enum { + value = ( ::boost::detail::is_convertible_basic_impl::value && ! ::boost::is_array::value && ! ::boost::is_function::value) + }; +}; +#elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551 +template +struct is_convertible_impl +{ + BOOST_STATIC_CONSTANT(bool, value = ( ::boost::detail::is_convertible_basic_impl::value && !::boost::is_array::value && !::boost::is_function::value)); +}; +#endif + +template +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef is_convertible_impl type; + }; +}; + +template <> +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef true_type type; + }; +}; + +template <> +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template <> +struct is_convertible_impl_select +{ + template + struct rebind + { + typedef false_type type; + }; +}; + +template +struct is_convertible_impl_dispatch_base +{ +#if !BOOST_WORKAROUND(__HP_aCC, < 60700) + typedef is_convertible_impl_select< + ::boost::is_arithmetic::value, + ::boost::is_arithmetic::value, +#if !defined(BOOST_NO_IS_ABSTRACT) && !defined(BOOST_TT_CXX11_IS_CONVERTIBLE) + // We need to filter out abstract types, only if we don't have a strictly conforming C++11 version: + ::boost::is_abstract::value +#else + false +#endif + > selector; +#else + typedef is_convertible_impl_select selector; +#endif + typedef typename selector::template rebind isc_binder; + typedef typename isc_binder::type type; +}; + +template +struct is_convertible_impl_dispatch + : public is_convertible_impl_dispatch_base::type +{}; + +// +// Now add the full and partial specialisations +// for void types, these are common to all the +// implementation above: +// +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS + +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; + +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; + +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; + +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; +template <> struct is_convertible_impl_dispatch : public true_type{}; + +#else +template <> struct is_convertible_impl_dispatch : public true_type{}; +#endif // BOOST_NO_CV_VOID_SPECIALIZATIONS + +template struct is_convertible_impl_dispatch : public false_type{}; +template struct is_convertible_impl_dispatch : public false_type{}; + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template struct is_convertible_impl_dispatch : public false_type{}; +template struct is_convertible_impl_dispatch : public false_type{}; +template struct is_convertible_impl_dispatch : public false_type{}; +template struct is_convertible_impl_dispatch : public false_type{}; +template struct is_convertible_impl_dispatch : public false_type{}; +template struct is_convertible_impl_dispatch : public false_type{}; +#endif + +} // namespace detail + +template +struct is_convertible : public integral_constant::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "Destination argument type to is_convertible must be a complete type"); + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "From argument type to is_convertible must be a complete type"); +}; + +#else + +template +struct is_convertible : public integral_constant +{ +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1900) + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value || boost::is_reference::value, "From argument type to is_convertible must be a complete type"); +#endif +#if defined(__clang__) + // clang's intrinsic doesn't assert on incomplete types: + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "Destination argument type to is_convertible must be a complete type"); + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value || boost::is_void::value || boost::is_array::value, "From argument type to is_convertible must be a complete type"); +#endif +}; + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_copy_assignable.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_copy_assignable.hpp new file mode 100644 index 00000000..ed04927b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_copy_assignable.hpp @@ -0,0 +1,140 @@ +// (C) Copyright Ion Gaztanaga 2014. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED +#define BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED + +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \ + && !defined(BOOST_INTEL_CXX_VERSION) && \ + !(defined(BOOST_MSVC) && _MSC_VER == 1800) +#define BOOST_TT_CXX11_IS_COPY_ASSIGNABLE +#include +#else + //For compilers without decltype + #include + #include + #include + #include +#endif + +namespace boost { + +namespace detail{ + +template +struct is_copy_assignable_impl2 { + +// Intel compiler has problems with SFINAE for copy constructors and deleted functions: +// +// error: function *function_name* cannot be referenced -- it is a deleted function +// static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval()))* = 0); +// ^ +// +// MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See: +// https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken +#if defined(BOOST_TT_CXX11_IS_COPY_ASSIGNABLE) + typedef boost::type_traits::yes_type yes_type; + typedef boost::type_traits::no_type no_type; + + template + static decltype(::boost::declval() = ::boost::declval(), yes_type() ) test(int); + + template + static no_type test(...); + + static const bool value = sizeof(test(0)) == sizeof(yes_type); + +#else + static BOOST_DEDUCED_TYPENAME boost::add_reference::type produce(); + + template + static boost::type_traits::no_type test(T1&, typename T1::boost_move_no_copy_constructor_or_assign* = 0); + + static boost::type_traits::yes_type test(...); + // If you see errors like this: + // + // `'T::operator=(const T&)' is private` + // `boost/type_traits/is_copy_assignable.hpp:NN:M: error: within this context` + // + // then you are trying to call that macro for a structure defined like that: + // + // struct T { + // ... + // private: + // T & operator=(const T &); + // ... + // }; + // + // To fix that you must modify your structure: + // + // // C++03 and C++11 version + // struct T: private boost::noncopyable { + // ... + // private: + // T & operator=(const T &); + // ... + // }; + // + // // C++11 version + // struct T { + // ... + // private: + // T& operator=(const T &) = delete; + // ... + // }; + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(test(produce())) == sizeof(boost::type_traits::yes_type) + )); + #endif +}; + +template +struct is_copy_assignable_impl2 { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct is_copy_assignable_impl { + +#if !defined(BOOST_TT_CXX11_IS_COPY_ASSIGNABLE) + //For compilers without decltype, at least return false on const types, arrays + //types derived from boost::noncopyable and types defined as BOOST_MOVEABLE_BUT_NOT_COPYABLE + typedef BOOST_DEDUCED_TYPENAME boost::remove_reference::type unreferenced_t; + BOOST_STATIC_CONSTANT(bool, value = ( + boost::detail::is_copy_assignable_impl2< + boost::is_noncopyable::value + || boost::is_const::value || boost::is_array::value + ,T + >::value + )); + #else + BOOST_STATIC_CONSTANT(bool, value = ( + boost::detail::is_copy_assignable_impl2< + boost::is_noncopyable::value,T + >::value + )); + #endif +}; + +} // namespace detail + +template struct is_copy_assignable : public integral_constant::value>{}; +template <> struct is_copy_assignable : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_copy_assignable : public false_type{}; +template <> struct is_copy_assignable : public false_type{}; +template <> struct is_copy_assignable : public false_type{}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_copy_constructible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_copy_constructible.hpp new file mode 100644 index 00000000..ef97e18e --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_copy_constructible.hpp @@ -0,0 +1,185 @@ +// (C) Copyright Antony Polukhin 2013. +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED + +#include +#include + +#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40900) + +#include + +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1800) + +namespace boost { + +template struct is_copy_constructible : public boost::is_constructible{}; + +template <> struct is_copy_constructible : public false_type{}; +template <> struct is_copy_constructible : public false_type{}; +template <> struct is_copy_constructible : public false_type{}; +template <> struct is_copy_constructible : public false_type{}; + +} // namespace boost + +#else +// +// Special version for VC12 which has a problem when a base class (such as non_copyable) has a deleted +// copy constructor. In this case the compiler thinks there really is a copy-constructor and tries to +// instantiate the deleted member. std::is_copy_constructible has the same issue (or at least returns +// an incorrect value, which just defers the issue into the users code) as well. We can at least fix +// boost::non_copyable as a base class as a special case: +// +#include + +namespace boost { + + namespace detail + { + + template struct is_copy_constructible_imp : public boost::is_constructible{}; + template struct is_copy_constructible_imp : public false_type{}; + + } + + template struct is_copy_constructible : public detail::is_copy_constructible_imp::value>{}; + + template <> struct is_copy_constructible : public false_type{}; + template <> struct is_copy_constructible : public false_type{}; + template <> struct is_copy_constructible : public false_type{}; + template <> struct is_copy_constructible : public false_type{}; + +} // namespace boost + +#endif + +#else + +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4181) +#endif + +namespace boost { + + namespace detail{ + + template + struct is_copy_constructible_impl2 { + + // Intel compiler has problems with SFINAE for copy constructors and deleted functions: + // + // error: function *function_name* cannot be referenced -- it is a deleted function + // static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval()))* = 0); + // ^ + // + // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See: + // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken +#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_INTEL_CXX_VERSION) && !(defined(BOOST_MSVC) && _MSC_VER == 1800) + +#ifdef BOOST_NO_CXX11_DECLTYPE + template + static boost::type_traits::yes_type test(const T1&, boost::mpl::int_()))>* = 0); +#else + template + static boost::type_traits::yes_type test(const T1&, decltype(T1(boost::declval()))* = 0); +#endif + + static boost::type_traits::no_type test(...); +#else + template + static boost::type_traits::no_type test(const T1&, typename T1::boost_move_no_copy_constructor_or_assign* = 0); + static boost::type_traits::yes_type test(...); +#endif + + // If you see errors like this: + // + // `'T::T(const T&)' is private` + // `boost/type_traits/is_copy_constructible.hpp:68:5: error: within this context` + // + // then you are trying to call that macro for a structure defined like that: + // + // struct T { + // ... + // private: + // T(const T &); + // ... + // }; + // + // To fix that you must modify your structure: + // + // // C++03 and C++11 version + // struct T: private boost::noncopyable { + // ... + // private: + // T(const T &); + // ... + // }; + // + // // C++11 version + // struct T { + // ... + // private: + // T(const T &) = delete; + // ... + // }; + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(test( + boost::declval::type>() + )) == sizeof(boost::type_traits::yes_type) + && + !boost::is_rvalue_reference::value + && !boost::is_array::value + )); + }; + + template + struct is_copy_constructible_impl2 { + BOOST_STATIC_CONSTANT(bool, value = false); + }; + + template + struct is_copy_constructible_impl { + + BOOST_STATIC_CONSTANT(bool, value = ( + boost::detail::is_copy_constructible_impl2< + boost::is_noncopyable::value, + T + >::value + )); + }; + + } // namespace detail + + template struct is_copy_constructible : public integral_constant::value>{}; + template <> struct is_copy_constructible : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS + template <> struct is_copy_constructible : public false_type{}; + template <> struct is_copy_constructible : public false_type{}; + template <> struct is_copy_constructible : public false_type{}; +#endif + +} // namespace boost + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +#endif + +#endif // BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_default_constructible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_default_constructible.hpp new file mode 100644 index 00000000..04c023fe --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_default_constructible.hpp @@ -0,0 +1,98 @@ + +// (C) Copyright John Maddock 2015. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED + +#include // size_t +#include +#include +#include +#include + +#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) +#include +#endif +#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5)) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1800)) +#include // std::pair +#endif + +#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) + +#include + +namespace boost{ + + namespace detail{ + + struct is_default_constructible_imp + { + template + static boost::type_traits::yes_type test(int); + + template + static boost::type_traits::no_type test(...); + }; +#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) + template + struct is_default_constructible_abstract_filter + { + static const bool value = sizeof(is_default_constructible_imp::test(0)) == sizeof(boost::type_traits::yes_type); + }; + template + struct is_default_constructible_abstract_filter + { + static const bool value = false; + }; +#endif + } + +#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) + template struct is_default_constructible : public integral_constant::value>::value> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_default_constructible must be complete types"); + }; +#else + template struct is_default_constructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_default_constructible must be complete types"); + }; +#endif + template struct is_default_constructible : public is_default_constructible{}; + template struct is_default_constructible : public is_default_constructible{}; + template struct is_default_constructible : public integral_constant{}; +#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ <= 5))|| (defined(BOOST_MSVC) && (BOOST_MSVC == 1800)) + template struct is_default_constructible > : public integral_constant::value && is_default_constructible::value>{}; +#endif +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + template struct is_default_constructible : public integral_constant{}; +#endif + template <> struct is_default_constructible : public integral_constant{}; + template <> struct is_default_constructible : public integral_constant{}; + template <> struct is_default_constructible : public integral_constant{}; + template <> struct is_default_constructible : public integral_constant{}; + +#else + +#include + +namespace boost{ + + // We don't know how to implement this, note we can not use has_trivial_constructor here + // because the correct implementation of that trait requires this one: + template struct is_default_constructible : public is_pod{}; + template <> struct is_default_constructible : public integral_constant{}; + template <> struct is_default_constructible : public integral_constant{}; + template <> struct is_default_constructible : public integral_constant{}; + template <> struct is_default_constructible : public integral_constant{}; + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_destructible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_destructible.hpp new file mode 100644 index 00000000..c32e758c --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_destructible.hpp @@ -0,0 +1,69 @@ + +// (C) Copyright John Maddock 2015. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED + +#include // size_t +#include +#include +#include +#include + +#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) + +#include +#include + +namespace boost{ + + namespace detail{ + + struct is_destructible_imp + { + template().~T())> + static boost::type_traits::yes_type test(int); + template + static boost::type_traits::no_type test(...); + }; + + } + + template struct is_destructible : public integral_constant(0)) == sizeof(boost::type_traits::yes_type)> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_destructible must be complete types"); + }; + +#else + +#include +#include + +namespace boost{ + + // We don't know how to implement this: + template struct is_destructible : public integral_constant::value || is_class::value> + { + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_destructible must be complete types"); + }; +#endif + + template <> struct is_destructible : public false_type{}; + template <> struct is_destructible : public false_type{}; + template <> struct is_destructible : public false_type{}; + template <> struct is_destructible : public false_type{}; + template struct is_destructible : public is_destructible{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + template struct is_destructible : public is_destructible{}; +#endif + template struct is_destructible : public is_destructible{}; + template struct is_destructible : public is_destructible{}; + +} // namespace boost + +#endif // BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected.hpp new file mode 100644 index 00000000..25dfa848 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected.hpp @@ -0,0 +1,29 @@ +/* +Copyright 2017-2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_IS_DETECTED_HPP_INCLUDED +#define BOOST_TT_IS_DETECTED_HPP_INCLUDED + +#include +#include + +namespace boost { + +template class Op, class... Args> +using is_detected = typename + detail::detector::value_t; + +#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES) +template class Op, class... Args> +constexpr bool is_detected_v = is_detected::value; +#endif + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected_convertible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected_convertible.hpp new file mode 100644 index 00000000..538ba25a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected_convertible.hpp @@ -0,0 +1,29 @@ +/* +Copyright 2017-2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_IS_DETECTED_CONVERTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_DETECTED_CONVERTIBLE_HPP_INCLUDED + +#include +#include + +namespace boost { + +template class Op, class... Args> +using is_detected_convertible = is_convertible, To>; + +#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES) +template class Op, class... Args> +constexpr bool is_detected_convertible_v = is_detected_convertible::value; +#endif + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected_exact.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected_exact.hpp new file mode 100644 index 00000000..34f714c8 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_detected_exact.hpp @@ -0,0 +1,29 @@ +/* +Copyright 2017-2018 Glen Joseph Fernandes +(glenjofe@gmail.com) + +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_TT_IS_DETECTED_EXACT_HPP_INCLUDED +#define BOOST_TT_IS_DETECTED_EXACT_HPP_INCLUDED + +#include +#include + +namespace boost { + +template class Op, class... Args> +using is_detected_exact = is_same >; + +#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES) +template class Op, class... Args> +constexpr bool is_detected_exact_v = is_detected_exact::value; +#endif + +} /* boost */ + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_empty.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_empty.hpp new file mode 100644 index 00000000..ef288c51 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_empty.hpp @@ -0,0 +1,120 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_EMPTY_HPP_INCLUDED +#define BOOST_TT_IS_EMPTY_HPP_INCLUDED + +#include +#include +#include + +#include +#include +#include + +#ifndef BOOST_INTERNAL_IS_EMPTY +#define BOOST_INTERNAL_IS_EMPTY(T) false +#else +#define BOOST_INTERNAL_IS_EMPTY(T) BOOST_IS_EMPTY(T) +#endif + +namespace boost { + +namespace detail { + + +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4624) // destructor could not be generated +#endif + +template +struct empty_helper_t1 : public T +{ + empty_helper_t1(); // hh compiler bug workaround + int i[256]; +private: + // suppress compiler warnings: + empty_helper_t1(const empty_helper_t1&); + empty_helper_t1& operator=(const empty_helper_t1&); +}; + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +struct empty_helper_t2 { int i[256]; }; + +#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT( + bool, value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)) + ); +}; + +template +struct is_empty_impl +{ + typedef typename remove_cv::type cvt; + BOOST_STATIC_CONSTANT( + bool, + value = ( ::boost::detail::empty_helper::value>::value || BOOST_INTERNAL_IS_EMPTY(cvt))); +}; + +#else // __BORLANDC__ + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(empty_helper_t1) == sizeof(empty_helper_t2) + )); +}; + +template +struct is_empty_impl +{ + typedef typename remove_cv::type cvt; + typedef typename add_reference::type r_type; + + BOOST_STATIC_CONSTANT( + bool, value = ( + ::boost::detail::empty_helper< + cvt + , ::boost::is_class::value + , ::boost::is_convertible< r_type,int>::value + >::value || BOOST_INTERNAL_IS_EMPTY(cvt)); +}; + +#endif // __BORLANDC__ + +} // namespace detail + +template struct is_empty : integral_constant::value> {}; + +} // namespace boost + +#undef BOOST_INTERNAL_IS_EMPTY + +#endif // BOOST_TT_IS_EMPTY_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_enum.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_enum.hpp new file mode 100644 index 00000000..eada480a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_enum.hpp @@ -0,0 +1,166 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_ENUM_HPP_INCLUDED +#define BOOST_TT_IS_ENUM_HPP_INCLUDED + +#include +#include +#ifndef BOOST_IS_ENUM +#include +#include +#include +#include +#include +#ifdef __GNUC__ +#include +#endif +#include +#if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) +# include +# include +#endif +#endif + +namespace boost { + +#ifndef BOOST_IS_ENUM +#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)) + +namespace detail { + +#if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) + +template +struct is_class_or_union +{ + BOOST_STATIC_CONSTANT(bool, value = ::boost::is_class::value || ::boost::is_union::value); +}; + +#else + +template +struct is_class_or_union +{ +# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way. + BOOST_STATIC_CONSTANT(bool, value = false); +# else + template static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void)); + +# if BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE + static ::boost::type_traits::no_type is_class_or_union_tester(...); + BOOST_STATIC_CONSTANT( + bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type)); +# else + template + static ::boost::type_traits::no_type is_class_or_union_tester(...); + BOOST_STATIC_CONSTANT( + bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type)); +# endif +# endif +}; +#endif + +struct int_convertible +{ + int_convertible(int); +}; + +// Don't evaluate convertibility to int_convertible unless the type +// is non-arithmetic. This suppresses warnings with GCC. +template +struct is_enum_helper +{ + template struct type + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template <> +struct is_enum_helper +{ + template struct type + { + static const bool value = ::boost::is_convertible::type, ::boost::detail::int_convertible>::value; + }; +}; + +template struct is_enum_impl +{ + //typedef ::boost::add_reference ar_t; + //typedef typename ar_t::type r_type; + +#if defined(__GNUC__) + +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + + // We MUST check for is_class_or_union on conforming compilers in + // order to correctly deduce that noncopyable types are not enums + // (dwa 2002/04/15)... + BOOST_STATIC_CONSTANT(bool, selector = + ::boost::is_arithmetic::value + || ::boost::is_reference::value + || ::boost::is_function::value + || is_class_or_union::value + || is_array::value); +#else + // ...however, not checking is_class_or_union on non-conforming + // compilers prevents a dependency recursion. + BOOST_STATIC_CONSTANT(bool, selector = + ::boost::is_arithmetic::value + || ::boost::is_reference::value + || ::boost::is_function::value + || is_array::value); +#endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + +#else // !defined(__GNUC__): + + BOOST_STATIC_CONSTANT(bool, selector = + ::boost::is_arithmetic::value + || ::boost::is_reference::value + || is_class_or_union::value + || is_array::value); + +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) + typedef ::boost::detail::is_enum_helper< + ::boost::detail::is_enum_impl::selector + > se_t; +#else + typedef ::boost::detail::is_enum_helper se_t; +#endif + + typedef typename se_t::template type helper; + BOOST_STATIC_CONSTANT(bool, value = helper::value); +}; + +} // namespace detail + +template struct is_enum : public integral_constant::value> {}; + +#else // __BORLANDC__ +// +// buggy is_convertible prevents working +// implementation of is_enum: +template struct is_enum : public integral_constant {}; + +#endif + +#else // BOOST_IS_ENUM + +template struct is_enum : public integral_constant {}; + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_ENUM_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_final.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_final.hpp new file mode 100644 index 00000000..21ac93f3 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_final.hpp @@ -0,0 +1,30 @@ + +// Copyright (c) 2014 Agustin Berge +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_FINAL_HPP_INCLUDED +#define BOOST_TT_IS_FINAL_HPP_INCLUDED + +#include +#include +#ifdef BOOST_IS_FINAL +#include +#endif + +namespace boost { + +#ifdef BOOST_IS_FINAL +template struct is_final : public integral_constant {}; +#else +template struct is_final : public integral_constant {}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_FINAL_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_float.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_float.hpp new file mode 100644 index 00000000..7bf7d1f8 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_float.hpp @@ -0,0 +1,20 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED + +// should be the last #include +#include + +namespace boost { + +//* is a type T a floating-point type described in the standard (3.9.1p8) + template struct is_float : public is_floating_point {}; +} // namespace boost + +#endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_floating_point.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_floating_point.hpp new file mode 100644 index 00000000..196c900c --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_floating_point.hpp @@ -0,0 +1,30 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000-2005. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TYPE_TRAITS_IS_FLOATING_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_FLOATING_HPP_INCLUDED + +#include + +namespace boost { + +//* is a type T a floating-point type described in the standard (3.9.1p8) + template struct is_floating_point : public false_type{}; + template struct is_floating_point : public is_floating_point{}; + template struct is_floating_point : public is_floating_point{}; + template struct is_floating_point : public is_floating_point{}; + template<> struct is_floating_point : public true_type{}; + template<> struct is_floating_point : public true_type{}; + template<> struct is_floating_point : public true_type{}; + +#if defined(BOOST_HAS_FLOAT128) + template<> struct is_floating_point<__float128> : public true_type{}; +#endif + +} // namespace boost + +#endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_function.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_function.hpp new file mode 100644 index 00000000..8556235a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_function.hpp @@ -0,0 +1,27 @@ + +// Copyright 2000 John Maddock (john@johnmaddock.co.uk) +// Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) +// +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNCTION_HPP_INCLUDED +#define BOOST_TT_IS_FUNCTION_HPP_INCLUDED + +#include +#include + +#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION + +#include + +#else + +#include + +#endif + +#endif // BOOST_TT_IS_FUNCTION_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_fundamental.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_fundamental.hpp new file mode 100644 index 00000000..f58767a4 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_fundamental.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED +#define BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED + +#include +#include + +namespace boost { + +//* is a type T a fundamental type described in the standard (3.9.1) +#if defined( __CODEGEARC__ ) +template struct is_fundamental : public integral_constant {}; +#else +template struct is_fundamental : public integral_constant::value || ::boost::is_void::value> {}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_integral.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_integral.hpp new file mode 100644 index 00000000..7a7e54bb --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_integral.hpp @@ -0,0 +1,89 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_INTEGRAL_HPP_INCLUDED +#define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED + +#include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) + template + struct is_integral : public integral_constant {}; +#else + +template struct is_integral : public false_type {}; +template struct is_integral : public is_integral {}; +template struct is_integral : public is_integral{}; +template struct is_integral : public is_integral{}; + +//* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3) +// as an extension we include long long, as this is likely to be added to the +// standard at a later date +template<> struct is_integral : public true_type {}; +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; + +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; + +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +// If the following line fails to compile and you're using the Intel +// compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php, +// and define BOOST_NO_INTRINSIC_WCHAR_T on the command line. +template<> struct is_integral : public true_type{}; +#endif + +// Same set of integral types as in boost/type_traits/integral_promotion.hpp. +// Please, keep in sync. -- Alexander Nasonov +#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ + || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300)) +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; +template<> struct is_integral<__int8> : public true_type{}; +template<> struct is_integral<__int16> : public true_type{}; +template<> struct is_integral<__int32> : public true_type{}; +#ifdef __BORLANDC__ +template<> struct is_integral : public true_type{}; +template<> struct is_integral<__int64> : public true_type{}; +#endif +#endif + +# if defined(BOOST_HAS_LONG_LONG) +template<> struct is_integral< ::boost::ulong_long_type> : public true_type{}; +template<> struct is_integral< ::boost::long_long_type> : public true_type{}; +#elif defined(BOOST_HAS_MS_INT64) +template<> struct is_integral : public true_type{}; +template<> struct is_integral<__int64> : public true_type{}; +#endif + +#ifdef BOOST_HAS_INT128 +template<> struct is_integral : public true_type{}; +template<> struct is_integral : public true_type{}; +#endif +#ifndef BOOST_NO_CXX11_CHAR16_T +template<> struct is_integral : public true_type{}; +#endif +#ifndef BOOST_NO_CXX11_CHAR32_T +template<> struct is_integral : public true_type{}; +#endif + +#endif // non-CodeGear implementation + +} // namespace boost + +#endif // BOOST_TT_IS_INTEGRAL_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_list_constructible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_list_constructible.hpp new file mode 100644 index 00000000..4a9f84ad --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_list_constructible.hpp @@ -0,0 +1,48 @@ +#ifndef BOOST_TYPE_TRAITS_IS_LIST_CONSTRUCTIBLE_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_LIST_CONSTRUCTIBLE_HPP_INCLUDED + +// Copyright 2017 Peter Dimov +// +// 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 +#include +#include +#include +#include +#include + +namespace boost +{ + +#if defined(BOOST_NO_SFINAE_EXPR) || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE) \ + || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)\ + || BOOST_WORKAROUND(BOOST_GCC, < 40700) + +template struct is_list_constructible: false_type +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_list_constructible must be complete types"); +}; + +#else + +namespace type_traits_detail +{ + +template()...} )> true_type is_list_constructible_impl( int ); +template false_type is_list_constructible_impl( ... ); + +} // namespace type_traits_detail + +template struct is_list_constructible: decltype( type_traits_detail::is_list_constructible_impl(0) ) +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_list_constructible must be complete types"); +}; + +#endif + +} // namespace boost + +#endif // #ifndef BOOST_TYPE_TRAITS_IS_LIST_CONSTRUCTIBLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_lvalue_reference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_lvalue_reference.hpp new file mode 100644 index 00000000..e94d7874 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_lvalue_reference.hpp @@ -0,0 +1,50 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_lvalue_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED + +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) + template struct is_lvalue_reference : public integral_constant{}; +#else + + template struct is_lvalue_reference : public false_type{}; + template struct is_lvalue_reference : public true_type{}; + +#if defined(BOOST_ILLEGAL_CV_REFERENCES) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... + template struct is_lvalue_reference : public true_type{}; + template struct is_lvalue_reference : public true_type{}; + template struct is_lvalue_reference : public true_type{}; +#endif + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_function_pointer.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_function_pointer.hpp new file mode 100644 index 00000000..9b5dbbf2 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_function_pointer.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED + +#include + +#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION + +#include + +#else + +#include + +#endif + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_object_pointer.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_object_pointer.hpp new file mode 100644 index 00000000..cb7cf14a --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_object_pointer.hpp @@ -0,0 +1,24 @@ + +// (C) Copyright John Maddock 2005. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + + +#ifndef BOOST_TT_IS_MEMBER_OBJECT_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_OBJECT_POINTER_HPP_INCLUDED + +#include +#include + +namespace boost { + +template struct is_member_object_pointer + : public integral_constant::value && !::boost::is_member_function_pointer::value>{}; + +} // namespace boost + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_pointer.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_pointer.hpp new file mode 100644 index 00000000..9757afc9 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_member_pointer.hpp @@ -0,0 +1,45 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED + +#include +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) +template struct is_member_pointer : public integral_constant{}; +#else +template struct is_member_pointer : public integral_constant::value>{}; +template struct is_member_pointer : public true_type{}; + +#if !BOOST_WORKAROUND(__MWERKS__,<=0x3003) && !BOOST_WORKAROUND(__IBMCPP__, <=600) +template struct is_member_pointer : public true_type{}; +template struct is_member_pointer : public true_type{}; +template struct is_member_pointer : public true_type{}; +#endif + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_noncopyable.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_noncopyable.hpp new file mode 100644 index 00000000..787103ea --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_noncopyable.hpp @@ -0,0 +1,39 @@ +#ifndef BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED + +// +// Copyright 2018 Peter Dimov +// +// 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 +// +// is_noncopyable returns whether T is derived from boost::noncopyable +// + +#include + +namespace boost +{ + +#ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED +#define BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED + +// boost::noncopyable derives from noncopyable_::base_token to enable us +// to recognize it. The definition is macro-guarded so that we can replicate +// it here without including boost/core/noncopyable.hpp, which is in Core. + +namespace noncopyable_ +{ + struct base_token {}; +} + +#endif // #ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED + +template struct is_noncopyable: is_base_and_derived +{ +}; + +} // namespace boost + +#endif // #ifndef BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_move_assignable.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_move_assignable.hpp new file mode 100644 index 00000000..c6194de8 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_move_assignable.hpp @@ -0,0 +1,92 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED +#define BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace boost { + +#ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN + +template +struct is_nothrow_move_assignable : public integral_constant +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_assignable must be complete types"); +}; +template struct is_nothrow_move_assignable : public false_type{}; +template struct is_nothrow_move_assignable : public false_type{}; +template struct is_nothrow_move_assignable : public false_type{}; +template struct is_nothrow_move_assignable : public false_type{}; +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +template struct is_nothrow_move_assignable : public false_type{}; +#endif + +#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) + +namespace detail{ + +template +struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {}; + +template +struct false_or_cpp11_noexcept_move_assignable < + T, + typename ::boost::enable_if_() = ::boost::declval())>::type + > : public ::boost::integral_constant() = ::boost::declval())> +{}; + +} + +template +struct is_nothrow_move_assignable : public integral_constant::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_assignable must be complete types"); +}; + +template struct is_nothrow_move_assignable : public ::boost::false_type {}; +template struct is_nothrow_move_assignable : public ::boost::false_type{}; +template struct is_nothrow_move_assignable : public ::boost::false_type{}; +template struct is_nothrow_move_assignable : public ::boost::false_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template struct is_nothrow_move_assignable : public ::boost::false_type{}; +#endif + +#else + +template +struct is_nothrow_move_assignable : public integral_constant::value || ::boost::has_nothrow_assign::value) && ! ::boost::is_array::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_assignable must be complete types"); +}; + +#endif + + +template <> struct is_nothrow_move_assignable : public false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_nothrow_move_assignable : public false_type{}; +template <> struct is_nothrow_move_assignable : public false_type{}; +template <> struct is_nothrow_move_assignable : public false_type{}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_NOTHROW_MOVE_ASSIGNABLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_move_constructible.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_move_constructible.hpp new file mode 100644 index 00000000..60c2994d --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_move_constructible.hpp @@ -0,0 +1,97 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// (C) Copyright Eric Friedman 2002-2003. +// (C) Copyright Antony Polukhin 2013. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED + +#include // size_t +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT + +namespace boost { + +template +struct is_nothrow_move_constructible : public integral_constant +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_constructible must be complete types"); +}; + +template struct is_nothrow_move_constructible : public ::boost::false_type {}; +template struct is_nothrow_move_constructible : public ::boost::false_type{}; + +#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700) + +#include +#include + +namespace boost{ namespace detail{ + +template +struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {}; + +template +struct false_or_cpp11_noexcept_move_constructible < + T, + typename ::boost::enable_if_()))>::type + > : public ::boost::integral_constant()))> +{}; + +} + +template struct is_nothrow_move_constructible + : public integral_constant::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_constructible must be complete types"); +}; + +template struct is_nothrow_move_constructible : public ::boost::false_type {}; +template struct is_nothrow_move_constructible : public ::boost::false_type{}; +template struct is_nothrow_move_constructible : public ::boost::false_type{}; +template struct is_nothrow_move_constructible : public ::boost::false_type{}; + +#else + +#include +#include +#include + +namespace boost{ + +template +struct is_nothrow_move_constructible + : public integral_constant::value || ::boost::has_nothrow_copy::value) && !::boost::is_array::value> +{ + BOOST_STATIC_ASSERT_MSG(boost::is_complete::value, "Arguments to is_nothrow_move_constructible must be complete types"); +}; + +#endif + +template <> struct is_nothrow_move_constructible : false_type{}; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_nothrow_move_constructible : false_type{}; +template <> struct is_nothrow_move_constructible : false_type{}; +template <> struct is_nothrow_move_constructible : false_type{}; +#endif +// References are always trivially constructible, even if the thing they reference is not: +template struct is_nothrow_move_constructible : public ::boost::true_type{}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template struct is_nothrow_move_constructible : public ::boost::true_type{}; +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_swappable.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_swappable.hpp new file mode 100644 index 00000000..10ad9239 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_nothrow_swappable.hpp @@ -0,0 +1,67 @@ +#ifndef BOOST_TYPE_TRAITS_IS_NOTHROW_SWAPPABLE_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_NOTHROW_SWAPPABLE_HPP_INCLUDED + +// Copyright 2017 Peter Dimov +// +// 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 +#include + +#if defined(BOOST_NO_SFINAE_EXPR) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DECLTYPE) \ + || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) || BOOST_WORKAROUND(BOOST_GCC, < 40700) + +#include +#include +#include + +namespace boost +{ +template struct is_nothrow_swappable : boost::integral_constant::value && !boost::is_const::value> {}; + +template struct is_nothrow_swappable_with : false_type {}; +template struct is_nothrow_swappable_with : is_nothrow_swappable {}; +} + +#else + +#include +#include +#include + +namespace boost +{ + +namespace type_traits_swappable_detail +{ + +using std::swap; + +template(), declval()))> integral_constant is_nothrow_swappable_with_impl( int ); +template false_type is_nothrow_swappable_with_impl( ... ); +template +struct is_nothrow_swappable_with_helper { typedef decltype( type_traits_swappable_detail::is_nothrow_swappable_with_impl(0) ) type; }; + +template(), declval()))> integral_constant is_nothrow_swappable_impl( int ); +template false_type is_nothrow_swappable_impl( ... ); +template +struct is_nothrow_swappable_helper { typedef decltype( type_traits_swappable_detail::is_nothrow_swappable_impl(0) ) type; }; + +} // namespace type_traits_swappable_detail + +template struct is_nothrow_swappable_with: type_traits_swappable_detail::is_nothrow_swappable_with_helper::type +{ +}; + +template struct is_nothrow_swappable: type_traits_swappable_detail::is_nothrow_swappable_helper::type +{ +}; + +} // namespace boost + +#endif + +#endif // #ifndef BOOST_TYPE_TRAITS_IS_NOTHROW_SWAPPABLE_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_object.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_object.hpp new file mode 100644 index 00000000..fc9d2f25 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_object.hpp @@ -0,0 +1,28 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_OBJECT_HPP_INCLUDED +#define BOOST_TT_IS_OBJECT_HPP_INCLUDED + +#include +#include +#include +#include + +namespace boost { + +template struct is_object + : public + integral_constant< + bool, + ! ::boost::is_reference::value && ! ::boost::is_void::value && ! ::boost::is_function::value > +{}; + +} // namespace boost + +#endif // BOOST_TT_IS_OBJECT_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_pod.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_pod.hpp new file mode 100644 index 00000000..9bd19625 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_pod.hpp @@ -0,0 +1,59 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_POD_HPP_INCLUDED +#define BOOST_TT_IS_POD_HPP_INCLUDED + +#include // size_t +#include +#include +#include +#include + +#ifdef __SUNPRO_CC +#include +#endif + +#include + +#ifndef BOOST_IS_POD +#define BOOST_INTERNAL_IS_POD(T) false +#else +#define BOOST_INTERNAL_IS_POD(T) BOOST_IS_POD(T) +#endif + +namespace boost { + +// forward declaration, needed by 'is_pod_array_helper' template below +template< typename T > struct is_POD; + +template struct is_pod +: public integral_constant::value || ::boost::is_void::value || BOOST_INTERNAL_IS_POD(T)> +{}; + +#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) +template struct is_pod : public is_pod{}; +#endif + + +// the following help compilers without partial specialization support: +template<> struct is_pod : public true_type{}; + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template<> struct is_pod : public true_type{}; +template<> struct is_pod : public true_type{}; +template<> struct is_pod : public true_type{}; +#endif + +template struct is_POD : public is_pod{}; + +} // namespace boost + +#undef BOOST_INTERNAL_IS_POD + +#endif // BOOST_TT_IS_POD_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_pointer.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_pointer.hpp new file mode 100644 index 00000000..44b06c22 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_pointer.hpp @@ -0,0 +1,47 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_POINTER_HPP_INCLUDED + +#include + +namespace boost { + +#if defined( __CODEGEARC__ ) +template struct is_pointer : public integral_constant{}; +#else +template struct is_pointer : public false_type{}; +template struct is_pointer : public true_type{}; +template struct is_pointer : public true_type{}; +template struct is_pointer : public true_type{}; +template struct is_pointer : public true_type{}; + +#ifdef BOOST_MSVC +template struct is_pointer : public is_pointer{}; +template struct is_pointer : public is_pointer{}; +template struct is_pointer : public is_pointer{}; +#endif + +#endif + +} // namespace boost + +#endif // BOOST_TT_IS_POINTER_HPP_INCLUDED diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_polymorphic.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_polymorphic.hpp new file mode 100644 index 00000000..722d8b46 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_polymorphic.hpp @@ -0,0 +1,122 @@ +// (C) Copyright John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_POLYMORPHIC_HPP +#define BOOST_TT_IS_POLYMORPHIC_HPP + +#include +#include +#ifndef BOOST_IS_POLYMORPHIC +#include +#endif +#include + +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700) +#pragma warning(push) +#pragma warning(disable:4250) +#endif + +namespace boost{ + +#ifndef BOOST_IS_POLYMORPHIC + +namespace detail{ + +template +struct is_polymorphic_imp1 +{ +# if BOOST_WORKAROUND(__MWERKS__, <= 0x2407) // CWPro7 should return false always. + typedef char d1, (&d2)[2]; +# else + struct d1 : public T + { + d1(); +# if !defined(__GNUC__) // this raises warnings with some classes, and buys nothing with GCC + ~d1()throw(); +# endif + char padding[256]; + private: + // keep some picky compilers happy: + d1(const d1&); + d1& operator=(const d1&); + }; + struct d2 : public T + { + d2(); + virtual ~d2()throw(); +# if !defined(BOOST_MSVC) && !defined(__ICL) + // for some reason this messes up VC++ when T has virtual bases, + // probably likewise for compilers that use the same ABI: + struct unique{}; + virtual void unique_name_to_boost5487629(unique*); +# endif + char padding[256]; + private: + // keep some picky compilers happy: + d2(const d2&); + d2& operator=(const d2&); + }; +# endif + BOOST_STATIC_CONSTANT(bool, value = (sizeof(d2) == sizeof(d1))); +}; + +template struct is_polymorphic_imp1 : public is_polymorphic_imp1{}; +template struct is_polymorphic_imp1 : public is_polymorphic_imp1{}; +template struct is_polymorphic_imp1 : public is_polymorphic_imp1{}; + +template +struct is_polymorphic_imp2 +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct is_polymorphic_selector +{ + template + struct rebind + { + typedef is_polymorphic_imp2 type; + }; +}; + +template <> +struct is_polymorphic_selector +{ + template + struct rebind + { + typedef is_polymorphic_imp1 type; + }; +}; + +template +struct is_polymorphic_imp +{ + typedef is_polymorphic_selector< ::boost::is_class::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type imp_type; + BOOST_STATIC_CONSTANT(bool, value = imp_type::value); +}; + +} // namespace detail + +template struct is_polymorphic : public integral_constant::value> {}; + +#else // BOOST_IS_POLYMORPHIC + +template struct is_polymorphic : public integral_constant {}; + +#endif + +} // namespace boost + +#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700) +#pragma warning(pop) +#endif + +#endif diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_reference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_reference.hpp new file mode 100644 index 00000000..85f0a632 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_reference.hpp @@ -0,0 +1,30 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000, 2010. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED + +#include +#include + +namespace boost { + +template struct is_reference + : public + integral_constant< + bool, + ::boost::is_lvalue_reference::value || ::boost::is_rvalue_reference::value> +{}; + +} // namespace boost + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_rvalue_reference.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_rvalue_reference.hpp new file mode 100644 index 00000000..37d33c95 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_rvalue_reference.hpp @@ -0,0 +1,29 @@ + +// (C) Copyright John Maddock 2010. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED + +#include +#include + +namespace boost { + +template struct is_rvalue_reference : public false_type {}; +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +template struct is_rvalue_reference : public true_type {}; +#endif + +} // namespace boost + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1700) +#include +#endif + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_same.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_same.hpp new file mode 100644 index 00000000..d16f4b2b --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_same.hpp @@ -0,0 +1,41 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Howard Hinnant and John Maddock 2000. +// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 + +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). + + +#ifndef BOOST_TT_IS_SAME_HPP_INCLUDED +#define BOOST_TT_IS_SAME_HPP_INCLUDED + +#include + +namespace boost { + + + template struct is_same : public false_type {}; + template struct is_same : public true_type {}; +#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) +// without this, Borland's compiler gives the wrong answer for +// references to arrays: + template struct is_same : public true_type{}; +#endif + + +} // namespace boost + +#endif // BOOST_TT_IS_SAME_HPP_INCLUDED + diff --git a/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_scalar.hpp b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_scalar.hpp new file mode 100644 index 00000000..30314405 --- /dev/null +++ b/sonic3air-main/Oxygen/sonic3air/build/_xcode/boost.framework/Versions/A/Headers/type_traits/is_scalar.hpp @@ -0,0 +1,27 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. + +#ifndef BOOST_TT_IS_SCALAR_HPP_INCLUDED +#define BOOST_TT_IS_SCALAR_HPP_INCLUDED + +#include +#include +#include +#include +#include + +namespace boost { + +template +struct is_scalar + : public integral_constant::value || ::boost::is_enum::value || ::boost::is_pointer::value || ::boost::is_member_pointer::value> +{}; + +} // namespace boost + +#endif // BOOST_TT_IS_SCALAR_HPP_INCLUDED