CCF_100/suyu-mirror
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu synced 2025-09-12 09:07:59 -05:00
Code Issues Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Crimson-Hawk
2024-03-05 16:42:40 +08:00
commit f1e4595ebf
39576 changed files with 7006612 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
externals/vcpkg/packages/boost-ratio_x64-windows/BUILD_INFO vendored Executable file
View File

@@ -0,0 +1,2 @@
CRTLinkage: dynamic
LibraryLinkage: dynamic

8
externals/vcpkg/packages/boost-ratio_x64-windows/CONTROL vendored Executable file
View File

@@ -0,0 +1,8 @@
Package: boost-ratio
Version: 1.79.0
Depends: boost-config, boost-core, boost-integer, boost-mpl, boost-rational, boost-static-assert, boost-type-traits, boost-vcpkg-helpers
Architecture: x64-windows
Multi-Arch: same
Abi: 2ff24914ebec67ffcef3caa61c2b8947741fbeaf9122e6efdce1ba4d778abe8e
Description: Boost ratio module
Type: Port

14
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio.hpp vendored Executable file
View File

@@ -0,0 +1,14 @@
// ratio.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_RATIO_HPP
#define BOOST_RATIO_HPP
#include <boost/ratio/include.hpp>
#endif // BOOST_RATIO_HPP

96
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/config.hpp vendored Executable file
View File

@@ -0,0 +1,96 @@
// config.hpp ---------------------------------------------------------------//
// Copyright 2012 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_RATIO_CONFIG_HPP
#define BOOST_RATIO_CONFIG_HPP
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
# if ! defined BOOST_NO_CXX11_U16STRING
# define BOOST_NO_CXX11_U16STRING
# endif
# if ! defined BOOST_NO_CXX11_U32STRING
# define BOOST_NO_CXX11_U32STRING
# endif
#endif
#if !defined BOOST_RATIO_VERSION
#define BOOST_RATIO_VERSION 1
#else
#if BOOST_RATIO_VERSION!=1 && BOOST_RATIO_VERSION!=2
#error "BOOST_RATIO_VERSION must be 1 or 2"
#endif
#endif
#if BOOST_RATIO_VERSION==1
#if ! defined BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
#define BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
#endif
#endif
#if BOOST_RATIO_VERSION==2
#if ! defined BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
#define BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
#endif
#endif
#ifdef INTMAX_C
#define BOOST_RATIO_INTMAX_C(a) INTMAX_C(a)
#elif __cplusplus >= 201103L
#define BOOST_RATIO_INTMAX_C(a) a##LL
#else
#define BOOST_RATIO_INTMAX_C(a) a##L
#endif
#ifdef UINTMAX_C
#define BOOST_RATIO_UINTMAX_C(a) UINTMAX_C(a)
#elif __cplusplus >= 201103L
#define BOOST_RATIO_UINTMAX_C(a) a##ULL
#else
#define BOOST_RATIO_UINTMAX_C(a) a##UL
#endif
#define BOOST_RATIO_INTMAX_T_MAX (0x7FFFFFFFFFFFFFFELL)
#ifndef BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
#elif defined(BOOST_RATIO_USES_STATIC_ASSERT)
#include <boost/static_assert.hpp>
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
#elif defined(BOOST_RATIO_USES_MPL_ASSERT)
#include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp>
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) \
BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
#else
//~ #elif defined(BOOST_RATIO_USES_ARRAY_ASSERT)
#define BOOST_RATIO_CONCAT(A,B) A##B
#define BOOST_RATIO_NAME(A,B) BOOST_RATIO_CONCAT(A,B)
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_RATIO_NAME(__boost_ratio_test_,__LINE__)[(CND)?1:-1]
//~ #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)
#endif
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_RATIO_USES_MPL_ASSERT)
#define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add"
#define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub"
#define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul"
#define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div"
#define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range"
#define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0"
#define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range"
#endif
//#define BOOST_RATIO_EXTENSIONS
#endif // header

89
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/abs.hpp vendored Executable file
View File

@@ -0,0 +1,89 @@
////////////////////////////////////////////////////////////////////
//
// Copyright Vicente J. Botet Escriba 2010
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
//
////////////////////////////////////////////////////////////////////
#ifndef BOOST_MPL_ABS_HPP_INCLUDED
#define BOOST_MPL_ABS_HPP_INCLUDED
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/aux_/config/integral.hpp>
#include <boost/mpl/aux_/config/static_constant.hpp>
#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& !defined(__CUDACC__) \
&& ( defined(BOOST_MSVC) \
|| BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
)
# define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
#endif
namespace boost { namespace mpl {
template< typename Tag > struct abs_impl;
template< typename T > struct abs_tag
{
typedef typename T::tag type;
};
template<
typename BOOST_MPL_AUX_NA_PARAM(N)
>
struct abs
: abs_impl<
typename abs_tag<N>::type
>::template apply<N>::type
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(1, abs, (N))
};
BOOST_MPL_AUX_NA_SPEC(1, abs)
template<
typename T
, T n1
>
struct abs_c
: abs<integral_c<T,n1> >
{
};
#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
namespace aux {
template< typename T, T n > struct abs_wknd
{
BOOST_STATIC_CONSTANT(T, value = (n < 0 ? -n : n));
typedef integral_c<T,value> type;
};
}
#endif
template<>
struct abs_impl<integral_c_tag>
{
#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
template< typename N > struct apply
: aux::abs_wknd< typename N::value_type, N::value >
#else
template< typename N > struct apply
: integral_c< typename N::value_type, ((N::value < 0) ? (-N::value) : N::value ) >
#endif
{
};
};
}}
#endif // BOOST_MPL_ABS_HPP_INCLUDED

124
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/gcd.hpp vendored Executable file
View File

@@ -0,0 +1,124 @@
////////////////////////////////////////////////////////////////////
//
// Copyright Vicente J. Botet Escriba 2010
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
//
////////////////////////////////////////////////////////////////////
#ifndef BOOST_MPL_GCD_HPP_INCLUDED
#define BOOST_MPL_GCD_HPP_INCLUDED
#include <boost/mpl/integral_c.hpp>
#include <boost/ratio/detail/mpl/abs.hpp>
#include <boost/mpl/aux_/largest_int.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/aux_/config/integral.hpp>
#include <boost/mpl/aux_/config/static_constant.hpp>
#include <boost/mpl/aux_/config/dependent_nttp.hpp>
#include <boost/cstdint.hpp>
#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& !defined(__CUDACC__) \
&& ( defined(BOOST_MSVC) \
|| BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
)
# define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
#endif
namespace boost { namespace mpl {
template< typename Tag1, typename Tag2 > struct gcd_impl;
template< typename T > struct gcd_tag
{
typedef typename T::tag type;
};
template<
typename BOOST_MPL_AUX_NA_PARAM(N1)
, typename BOOST_MPL_AUX_NA_PARAM(N2)
>
struct gcd
: gcd_impl<
typename gcd_tag<N1>::type
, typename gcd_tag<N2>::type
>::template apply<N1, N2>::type
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(2, gcd, (N1, N2))
};
BOOST_MPL_AUX_NA_SPEC(2, gcd)
template<
typename T
, T n1
, T n2
>
struct gcd_c
: gcd<integral_c<T,n1>,integral_c<T,n2> >
{
};
namespace aux {
// Workaround for error: the type of partial specialization template parameter constant "n2"
// depends on another template parameter
// Note: this solution could be wrong for n1 or n2 = [2**63 .. 2**64-1]
#if defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
template< typename T1, boost::intmax_t n1, bool n1_is_0
, typename T2, boost::intmax_t n2, bool n2_is_0 >
struct gcd_aux
: gcd_aux<T2, n2, n2==0, T1, (n1 % n2), (n1 % n2)==0>
{};
template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
{};
template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
{};
#else // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
template< typename T1, T1 n1, bool n1_is_0, typename T2, T2 n2, bool n2_is_0 >
struct gcd_aux
: gcd_aux<T2, n2, n2==0,
typename aux::largest_int<T1, T2>::type,
//~ T1,
(n1 % n2), (n1 % n2)==0>
{};
template <typename T1, T1 n1, typename T2, T2 n2>
struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
{};
template <typename T1, T1 n1, typename T2, T2 n2, bool C>
struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
{};
#endif // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
}
template<>
struct gcd_impl<integral_c_tag, integral_c_tag>
{
template< typename N1, typename N2 > struct apply
: abs<aux::gcd_aux< typename N1::value_type, N1::value, N1::value==0,
typename N2::value_type, N2::value, N2::value==0 > >
{
};
};
}}
#endif // BOOST_MPL_GCD_HPP_INCLUDED

126
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/lcm.hpp vendored Executable file
View File

@@ -0,0 +1,126 @@
////////////////////////////////////////////////////////////////////
//
// Copyright Vicente J. Botet Escriba 2010
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
//
////////////////////////////////////////////////////////////////////
#ifndef BOOST_MPL_LCM_HPP_INCLUDED
#define BOOST_MPL_LCM_HPP_INCLUDED
#include <boost/mpl/integral_c.hpp>
#include <boost/ratio/detail/mpl/abs.hpp>
#include <boost/mpl/aux_/largest_int.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/aux_/config/integral.hpp>
#include <boost/mpl/aux_/config/static_constant.hpp>
#include <boost/mpl/aux_/config/dependent_nttp.hpp>
#include <boost/cstdint.hpp>
#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& !defined(__CUDACC__) \
&& ( defined(BOOST_MSVC) \
|| BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
)
# define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
#endif
namespace boost { namespace mpl {
template< typename Tag1, typename Tag2 > struct lcm_impl;
template< typename T > struct lcm_tag
{
typedef typename T::tag type;
};
template<
typename BOOST_MPL_AUX_NA_PARAM(N1)
, typename BOOST_MPL_AUX_NA_PARAM(N2)
>
struct lcm
: lcm_impl<
typename lcm_tag<N1>::type
, typename lcm_tag<N2>::type
>::template apply<N1, N2>::type
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(2, lcm, (N1, N2))
};
BOOST_MPL_AUX_NA_SPEC(2, lcm)
template<
typename T
, T n1
, T n2
>
struct lcm_c
: lcm<integral_c<T,n1>,integral_c<T,n2> >
{
};
namespace aux {
// Workaround for error: the type of partial specialization template parameter constant "n2"
// depends on another template parameter
// Note: this solution could be wrong for n1 or n2 = [2**63 .. 2**64-1]
#if defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
template< typename T1, boost::intmax_t n1, bool n1_is_0
, typename T2, boost::intmax_t n2, bool n2_is_0 >
struct lcm_aux
: abs<integral_c< typename aux::largest_int<T1, T2>::type,
( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
> >
{};
template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
{};
template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
{};
#else // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
template< typename T1, T1 n1, bool n1_is_0, typename T2, T2 n2, bool n2_is_0 >
struct lcm_aux
: abs<integral_c< typename aux::largest_int<T1, T2>::type,
( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
> >
{};
template <typename T1, T1 n1, typename T2, T2 n2>
struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
{};
template <typename T1, T1 n1, typename T2, T2 n2, bool C>
struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
{};
#endif // defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC)
}
template<>
struct lcm_impl<integral_c_tag, integral_c_tag>
{
template< typename N1, typename N2 > struct apply
: abs<aux::lcm_aux< typename N1::value_type, N1::value, N1::value==0,
typename N2::value_type, N2::value, N2::value==0 > >
{
};
};
}}
#endif // BOOST_MPL_LCM_HPP_INCLUDED

89
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/mpl/sign.hpp vendored Executable file
View File

@@ -0,0 +1,89 @@
////////////////////////////////////////////////////////////////////
//
// Copyright Vicente J. Botet Escriba 2010
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
//
////////////////////////////////////////////////////////////////////
#ifndef BOOST_MPL_SIGN_HPP_INCLUDED
#define BOOST_MPL_SIGN_HPP_INCLUDED
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/aux_/config/integral.hpp>
#include <boost/mpl/aux_/config/static_constant.hpp>
#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2) \
&& !defined(BOOST_MPL_PREPROCESSING_MODE) \
&& !defined(__CUDACC__) \
&& ( defined(BOOST_MSVC) \
|| BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
)
# define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2
#endif
namespace boost { namespace mpl {
template< typename Tag > struct sign_impl;
template< typename T > struct sign_tag
{
typedef typename T::tag type;
};
template<
typename BOOST_MPL_AUX_NA_PARAM(N)
>
struct sign
: sign_impl<
typename sign_tag<N>::type
>::template apply<N>::type
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(1, sign, (N))
};
BOOST_MPL_AUX_NA_SPEC(1, sign)
template<
typename T
, T n1
>
struct sign_c
: sign<integral_c<T,n1> >
{
};
#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
namespace aux {
template< typename T, T n > struct sign_wknd
{
BOOST_STATIC_CONSTANT(T, value = (n == 0 ? 0 : (n < 0 ? -1 : 1)));
typedef integral_c<T,value> type;
};
}
#endif
template<>
struct sign_impl<integral_c_tag>
{
#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC_2)
template< typename N > struct apply
: aux::sign_wknd< typename N::value_type, N::value >
#else
template< typename N > struct apply
: integral_c< typename N::value_type, (N::value == 0 ? 0 : (N::value < 0 ? -1 : 1)) >
#endif
{
};
};
}}
#endif // BOOST_MPL_SIGN_HPP_INCLUDED

367
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/overflow_helpers.hpp vendored Executable file
View File

@@ -0,0 +1,367 @@
// ratio.hpp ---------------------------------------------------------------//
// Copyright 2008 Howard Hinnant
// Copyright 2008 Beman Dawes
// Copyright 2009 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
/*
This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
Many thanks to Howard for making his code available under the Boost license.
The original code was modified to conform to Boost conventions and to section
20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
paper N2798.
See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
time2_demo contained this comment:
Much thanks to Andrei Alexandrescu,
Walter Brown,
Peter Dimov,
Jeff Garland,
Terry Golubiewski,
Daniel Krugler,
Anthony Williams.
*/
// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
#ifndef BOOST_RATIO_DETAIL_RATIO_OPERATIONS_HPP
#define BOOST_RATIO_DETAIL_RATIO_OPERATIONS_HPP
#include <boost/ratio/config.hpp>
#include <boost/ratio/detail/mpl/abs.hpp>
#include <boost/ratio/detail/mpl/sign.hpp>
#include <cstdlib>
#include <climits>
#include <limits>
#include <boost/cstdint.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/integer_traits.hpp>
//
// We simply cannot include this header on gcc without getting copious warnings of the kind:
//
// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
//
// And yet there is no other reasonable implementation, so we declare this a system header
// to suppress these warnings.
//
#if defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif
namespace boost
{
//----------------------------------------------------------------------------//
// helpers //
//----------------------------------------------------------------------------//
namespace ratio_detail
{
template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
class br_add;
template <boost::intmax_t X, boost::intmax_t Y>
class br_add<X, Y, 1>
{
static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
BOOST_RATIO_STATIC_ASSERT(X <= max - Y , BOOST_RATIO_OVERFLOW_IN_ADD, ());
public:
static const boost::intmax_t value = X + Y;
};
template <boost::intmax_t X, boost::intmax_t Y>
class br_add<X, Y, 0>
{
public:
static const boost::intmax_t value = X;
};
template <boost::intmax_t X, boost::intmax_t Y>
class br_add<X, Y, -1>
{
static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
BOOST_RATIO_STATIC_ASSERT(min - Y <= X, BOOST_RATIO_OVERFLOW_IN_ADD, ());
public:
static const boost::intmax_t value = X + Y;
};
template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
class br_sub;
template <boost::intmax_t X, boost::intmax_t Y>
class br_sub<X, Y, 1>
{
static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
BOOST_RATIO_STATIC_ASSERT(min + Y <= X, BOOST_RATIO_OVERFLOW_IN_SUB, ());
public:
static const boost::intmax_t value = X - Y;
};
template <boost::intmax_t X, boost::intmax_t Y>
class br_sub<X, Y, 0>
{
public:
static const boost::intmax_t value = X;
};
template <boost::intmax_t X, boost::intmax_t Y>
class br_sub<X, Y, -1>
{
static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
BOOST_RATIO_STATIC_ASSERT(X <= max + Y, BOOST_RATIO_OVERFLOW_IN_SUB, ());
public:
static const boost::intmax_t value = X - Y;
};
template <boost::intmax_t X, boost::intmax_t Y>
class br_mul
{
static const boost::intmax_t nan =
boost::intmax_t(BOOST_RATIO_UINTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
static const boost::intmax_t a_x = mpl::abs_c<boost::intmax_t, X>::value;
static const boost::intmax_t a_y = mpl::abs_c<boost::intmax_t, Y>::value;
BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ());
BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_MUL, ());
BOOST_RATIO_STATIC_ASSERT(a_x <= max / a_y, BOOST_RATIO_OVERFLOW_IN_MUL, ());
public:
static const boost::intmax_t value = X * Y;
};
template <boost::intmax_t Y>
class br_mul<0, Y>
{
public:
static const boost::intmax_t value = 0;
};
template <boost::intmax_t X>
class br_mul<X, 0>
{
public:
static const boost::intmax_t value = 0;
};
template <>
class br_mul<0, 0>
{
public:
static const boost::intmax_t value = 0;
};
// Not actually used but left here in case needed in future maintenance
template <boost::intmax_t X, boost::intmax_t Y>
class br_div
{
static const boost::intmax_t nan = boost::intmax_t(BOOST_RATIO_UINTMAX_C(1) << (sizeof(boost::intmax_t) * CHAR_BIT - 1));
static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;
BOOST_RATIO_STATIC_ASSERT(X != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ());
BOOST_RATIO_STATIC_ASSERT(Y != nan, BOOST_RATIO_OVERFLOW_IN_DIV, ());
BOOST_RATIO_STATIC_ASSERT(Y != 0, BOOST_RATIO_DIVIDE_BY_0, ());
public:
static const boost::intmax_t value = X / Y;
};
// ratio arithmetic
template <class R1, class R2> struct ratio_add;
template <class R1, class R2> struct ratio_subtract;
template <class R1, class R2> struct ratio_multiply;
template <class R1, class R2> struct ratio_divide;
template <class R1, class R2>
struct ratio_add
{
//The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value R1::num *
//R2::den + R2::num * R1::den and T2 has the value R1::den * R2::den.
// As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
private:
static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
public:
// No need to normalize as ratio_multiply is already normalized
typedef typename ratio_multiply
<
ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
ratio
<
boost::ratio_detail::br_add
<
boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
>::value,
R2::den
>
>::type type;
};
template <class R, boost::intmax_t D>
struct ratio_add<R, ratio<0,D> >
{
typedef R type;
};
template <class R1, class R2>
struct ratio_subtract
{
//The nested typedef type shall be a synonym for ratio<T1, T2>::type where T1 has the value
// R1::num *R2::den - R2::num * R1::den and T2 has the value R1::den * R2::den.
// As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
private:
static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
public:
// No need to normalize as ratio_multiply is already normalized
typedef typename ratio_multiply
<
ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
ratio
<
boost::ratio_detail::br_sub
<
boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
>::value,
R2::den
>
>::type type;
};
template <class R, boost::intmax_t D>
struct ratio_subtract<R, ratio<0,D> >
{
typedef R type;
};
template <class R1, class R2>
struct ratio_multiply
{
// The nested typedef type shall be a synonym for ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type.
// As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
private:
static const boost::intmax_t gcd_n1_d2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::den>::value;
static const boost::intmax_t gcd_d1_n2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::num>::value;
public:
typedef typename ratio
<
boost::ratio_detail::br_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value,
boost::ratio_detail::br_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value
>::type type;
};
template <class R1, class R2>
struct ratio_divide
{
// The nested typedef type shall be a synonym for ratio<R1::num * R2::den, R2::num * R1::den>::type.
// As the preceding doesn't works because of overflow on boost::intmax_t we need something more elaborated.
private:
static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
public:
typedef typename ratio
<
boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
>::type type;
};
template <class R1, class R2>
struct is_evenly_divisible_by
{
private:
static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
public:
typedef integral_constant<bool,
((R2::num / gcd_n1_n2 ==1) && (R1::den / gcd_d1_d2)==1)
> type;
};
template <class T>
struct is_ratio : public boost::false_type
{};
template <boost::intmax_t N, boost::intmax_t D>
struct is_ratio<ratio<N, D> > : public boost::true_type
{};
template <class R1, class R2,
boost::intmax_t Q1 = R1::num / R1::den, boost::intmax_t M1 = R1::num % R1::den,
boost::intmax_t Q2 = R2::num / R2::den, boost::intmax_t M2 = R2::num % R2::den>
struct ratio_less1
{
static const bool value = Q1 < Q2;
};
template <class R1, class R2, boost::intmax_t Q>
struct ratio_less1<R1, R2, Q, 0, Q, 0>
{
static const bool value = false;
};
template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M2>
struct ratio_less1<R1, R2, Q, 0, Q, M2>
{
static const bool value = true;
};
template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1>
struct ratio_less1<R1, R2, Q, M1, Q, 0>
{
static const bool value = false;
};
template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1, boost::intmax_t M2>
struct ratio_less1<R1, R2, Q, M1, Q, M2>
{
static const bool value = ratio_less1<ratio<R2::den, M2>, ratio<R1::den, M1>
>::value;
};
template <
class R1,
class R2,
boost::intmax_t S1 = mpl::sign_c<boost::intmax_t, R1::num>::value,
boost::intmax_t S2 = mpl::sign_c<boost::intmax_t, R2::num>::value
>
struct ratio_less
{
static const bool value = S1 < S2;
};
template <class R1, class R2>
struct ratio_less<R1, R2, 1LL, 1LL>
{
static const bool value = ratio_less1<R1, R2>::value;
};
template <class R1, class R2>
struct ratio_less<R1, R2, -1LL, -1LL>
{
static const bool value = ratio_less1<ratio<-R2::num, R2::den>,
ratio<-R1::num, R1::den> >::value;
};
} // namespace ratio_detail
} // namespace boost
#endif // BOOST_RATIO_HPP

1342
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/detail/ratio_io.hpp vendored Executable file
View File

File diff suppressed because it is too large Load Diff

16
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/include.hpp vendored Executable file
View File

@@ -0,0 +1,16 @@
// include.hpp ---------------------------------------------------------------//
// Copyright 2011 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_RATIO_INCLUDE_HPP
#define BOOST_RATIO_INCLUDE_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/ratio_io.hpp>
#ifdef BOOST_RATIO_EXTENSIONS
#include <boost/ratio/mpl/rational_constant.hpp>
#endif
#endif // BOOST_RATIO_INCLUDE_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/abs.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// abs.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_ABS_HPP
#define BOOST_RATIO_MPL_ABS_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/ratio/detail/mpl/abs.hpp>
namespace boost {
namespace mpl {
template<>
struct abs_impl< rational_c_tag >
{
template< typename R > struct apply
: ratio_abs<R>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_ABS_HPP

22
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/arithmetic.hpp vendored Executable file
View File

@@ -0,0 +1,22 @@
// arithmetic.hpp ---------------------------------------------------------------//
// Copyright 2011 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_RATIO_MPL_ARITHMETIC_HPP
#define BOOST_RATIO_MPL_ARITHMETIC_HPP
#include <boost/ratio/mpl/plus.hpp>
#include <boost/ratio/mpl/minus.hpp>
#include <boost/ratio/mpl/times.hpp>
#include <boost/ratio/mpl/divides.hpp>
#include <boost/ratio/mpl/negate.hpp>
#include <boost/ratio/mpl/abs.hpp>
#include <boost/ratio/mpl/sign.hpp>
#include <boost/ratio/mpl/gcd.hpp>
#include <boost/ratio/mpl/lcm.hpp>
#endif // BOOST_RATIO_MPL_ARITHMETIC_HPP

19
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/comparison.hpp vendored Executable file
View File

@@ -0,0 +1,19 @@
// comparison.hpp ---------------------------------------------------------------//
// Copyright 2011 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_RATIO_MPL_COMPARISON_HPP
#define BOOST_RATIO_MPL_COMPARISON_HPP
#include <boost/ratio/mpl/equal_to.hpp>
#include <boost/ratio/mpl/not_equal_to.hpp>
#include <boost/ratio/mpl/less.hpp>
#include <boost/ratio/mpl/less_equal.hpp>
#include <boost/ratio/mpl/greater.hpp>
#include <boost/ratio/mpl/greater_equal.hpp>
#endif // BOOST_RATIO_MPL_COMPARISON_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/divides.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// divides.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_DIVIDES_HPP
#define BOOST_RATIO_MPL_DIVIDES_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/divides.hpp>
namespace boost {
namespace mpl {
template<>
struct divides_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_divide<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_DIVIDES_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/equal_to.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// equal_to.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_EQUAL_TO_HPP
#define BOOST_RATIO_MPL_EQUAL_TO_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/equal_to.hpp>
namespace boost {
namespace mpl {
template<>
struct equal_to_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_equal<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_EQUAL_TO_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/gcd.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// gcd.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_GCD_HPP
#define BOOST_RATIO_MPL_GCD_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/ratio/detail/mpl/gcd.hpp>
namespace boost {
namespace mpl {
template<>
struct gcd_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_gcd<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_GCD_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/greater.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// greater.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_GREATER_HPP
#define BOOST_RATIO_MPL_GREATER_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/greater.hpp>
namespace boost {
namespace mpl {
template<>
struct greater_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_greater<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_GREATER_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/greater_equal.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// greater_equal.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_GREATER_EQUAL_HPP
#define BOOST_RATIO_MPL_GREATER_EQUAL_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/greater_equal.hpp>
namespace boost {
namespace mpl {
template<>
struct greater_equal_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_greater_equal<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_GREATER_EQUAL_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/lcm.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// lcm.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_LCM_HPP
#define BOOST_RATIO_MPL_LCM_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/ratio/detail/mpl/lcm.hpp>
namespace boost {
namespace mpl {
template<>
struct lcm_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_lcm<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_LCM_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/less.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// less.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_LESS_HPP
#define BOOST_RATIO_MPL_LESS_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/less.hpp>
namespace boost {
namespace mpl {
template<>
struct less_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_less<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_LESS_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/less_equal.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// less_equal.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_LESS_EQUAL_HPP
#define BOOST_RATIO_MPL_LESS_EQUAL_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/less_equal.hpp>
namespace boost {
namespace mpl {
template<>
struct less_equal_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_less_equal<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_LESS_EQUAL_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/minus.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// minus.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_MINUS_HPP
#define BOOST_RATIO_MPL_MINUS_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/minus.hpp>
namespace boost {
namespace mpl {
template<>
struct minus_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_subtract<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_MINUS_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/negate.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// negate.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_NEGATE_HPP
#define BOOST_RATIO_MPL_NEGATE_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/negate.hpp>
namespace boost {
namespace mpl {
template<>
struct negate_impl< rational_c_tag >
{
template< typename R > struct apply
: ratio_negate<R>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_NEGATE_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/not_equal_to.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// not_equal_to.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_NOT_EQUAL_TO_HPP
#define BOOST_RATIO_MPL_NOT_EQUAL_TO_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/not_equal_to.hpp>
namespace boost {
namespace mpl {
template<>
struct not_equal_to_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_not_equal<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_NOT_EQUAL_TO_HPP

31
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/numeric_cast.hpp vendored Executable file
View File

@@ -0,0 +1,31 @@
// numeric_cast.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_NUMERIC_CAST_HPP
#define BOOST_RATIO_MPL_NUMERIC_CAST_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/ratio/mpl/rational_c_tag.hpp>
#include <boost/mpl/numeric_cast.hpp>
namespace boost {
namespace mpl {
template<> struct numeric_cast< integral_c_tag,rational_c_tag >
{
template< typename N > struct apply
: ratio< N::value, 1 >
{
};
};
}
}
#endif // BOOST_RATIO_MPL_NUMERIC_CAST_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/plus.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// plus.hpp
//
// (C) Copyright 2011Vicente J. Botet Escriba
// 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_RATIO_MPL_PLUS_HPP
#define BOOST_RATIO_MPL_PLUS_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/plus.hpp>
namespace boost {
namespace mpl {
template<>
struct plus_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_add<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_PLUS_HPP

25
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/rational_c_tag.hpp vendored Executable file
View File

@@ -0,0 +1,25 @@
// abs.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_RATIONAL_C_TAG_HPP
#define BOOST_RATIO_MPL_RATIONAL_C_TAG_HPP
#ifdef BOOST_RATIO_EXTENSIONS
#include <boost/mpl/int.hpp>
namespace boost {
namespace mpl {
struct rational_c_tag : int_<10> {};
}
}
#endif // BOOST_RATIO_EXTENSIONS
#endif // BOOST_RATIO_MPL_RATIONAL_C_TAG_HPP

15
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/rational_constant.hpp vendored Executable file
View File

@@ -0,0 +1,15 @@
// rational_constant.hpp ---------------------------------------------------------------//
// Copyright 2011 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_RATIO_MPL_RATIONAL_CONSTANT_HPP
#define BOOST_RATIO_MPL_RATIONAL_CONSTANT_HPP
#include <boost/ratio/mpl/rational_c_tag.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/ratio/mpl/arithmetic.hpp>
#include <boost/ratio/mpl/comparison.hpp>
#endif // BOOST_RATIO_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/sign.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// sign.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_SIGN_HPP
#define BOOST_RATIO_MPL_SIGN_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/ratio/detail/mpl/sign.hpp>
namespace boost {
namespace mpl {
template<>
struct sign_impl< rational_c_tag >
{
template< typename R > struct apply
: ratio_sign<R>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_SIGN_HPP

30
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/mpl/times.hpp vendored Executable file
View File

@@ -0,0 +1,30 @@
// times.hpp
//
// (C) Copyright 2011 Vicente J. Botet Escriba
// 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_RATIO_MPL_TIMES_HPP
#define BOOST_RATIO_MPL_TIMES_HPP
#include <boost/ratio/ratio.hpp>
#include <boost/ratio/mpl/numeric_cast.hpp>
#include <boost/mpl/times.hpp>
namespace boost {
namespace mpl {
template<>
struct times_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_multiply<R1, R2>
{
};
};
}
}
#endif // BOOST_RATIO_MPL_TIMES_HPP

293
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/ratio.hpp vendored Executable file
View File

@@ -0,0 +1,293 @@
// ratio.hpp ---------------------------------------------------------------//
// Copyright 2008 Howard Hinnant
// Copyright 2008 Beman Dawes
// Copyright 2009 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
/*
This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
Many thanks to Howard for making his code available under the Boost license.
The original code was modified to conform to Boost conventions and to section
20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
paper N2798.
See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
time2_demo contained this comment:
Much thanks to Andrei Alexandrescu,
Walter Brown,
Peter Dimov,
Jeff Garland,
Terry Golubiewski,
Daniel Krugler,
Anthony Williams.
*/
// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
#ifndef BOOST_RATIO_RATIO_HPP
#define BOOST_RATIO_RATIO_HPP
#include <boost/ratio/config.hpp>
#include <boost/ratio/detail/mpl/abs.hpp>
#include <boost/ratio/detail/mpl/sign.hpp>
#include <boost/ratio/detail/mpl/gcd.hpp>
#include <boost/ratio/detail/mpl/lcm.hpp>
#include <cstdlib>
#include <climits>
#include <limits>
#include <boost/cstdint.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/integer_traits.hpp>
#include <boost/ratio/ratio_fwd.hpp>
#include <boost/ratio/detail/overflow_helpers.hpp>
#ifdef BOOST_RATIO_EXTENSIONS
#include <boost/rational.hpp>
#include <boost/ratio/mpl/rational_c_tag.hpp>
#endif
//
// We simply cannot include this header on gcc without getting copious warnings of the kind:
//
// boost/integer.hpp:77:30: warning: use of C99 long long integer constant
//
// And yet there is no other reasonable implementation, so we declare this a system header
// to suppress these warnings.
//
#if defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif
namespace boost
{
//----------------------------------------------------------------------------//
// //
// 20.6.1 Class template ratio [ratio.ratio] //
// //
//----------------------------------------------------------------------------//
template <boost::intmax_t N, boost::intmax_t D>
class ratio
{
static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
BOOST_RATIO_STATIC_ASSERT(ABS_N >= 0, BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE, ());
BOOST_RATIO_STATIC_ASSERT(ABS_D > 0, BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE, ());
BOOST_RATIO_STATIC_ASSERT(D != 0, BOOST_RATIO_DIVIDE_BY_0 , ());
static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
* mpl::sign_c<boost::intmax_t,D>::value;
static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
public:
BOOST_STATIC_CONSTEXPR boost::intmax_t num = SIGN_N * ABS_N / GCD;
BOOST_STATIC_CONSTEXPR boost::intmax_t den = ABS_D / GCD;
#ifdef BOOST_RATIO_EXTENSIONS
typedef mpl::rational_c_tag tag;
typedef boost::rational<boost::intmax_t> value_type;
typedef boost::intmax_t num_type;
typedef boost::intmax_t den_type;
ratio()
{}
template <boost::intmax_t _N2, boost::intmax_t _D2>
ratio(const ratio<_N2, _D2>&,
typename enable_if_c
<
(ratio<_N2, _D2>::num == num &&
ratio<_N2, _D2>::den == den)
>::type* = 0)
{}
template <boost::intmax_t _N2, boost::intmax_t _D2>
typename enable_if_c
<
(ratio<_N2, _D2>::num == num &&
ratio<_N2, _D2>::den == den),
ratio&
>::type
operator=(const ratio<_N2, _D2>&) {return *this;}
static value_type value() {return value_type(num,den);}
value_type operator()() const {return value();}
#endif
typedef ratio<num, den> type;
};
#if defined(BOOST_NO_CXX11_CONSTEXPR)
template <boost::intmax_t N, boost::intmax_t D>
const boost::intmax_t ratio<N, D>::num;
template <boost::intmax_t N, boost::intmax_t D>
const boost::intmax_t ratio<N, D>::den;
#endif
//----------------------------------------------------------------------------//
// //
// 20.6.2 Arithmetic on ratio types [ratio.arithmetic] //
// //
//----------------------------------------------------------------------------//
template <class R1, class R2>
struct ratio_add
: boost::ratio_detail::ratio_add<R1, R2>::type
{
};
template <class R1, class R2>
struct ratio_subtract
: boost::ratio_detail::ratio_subtract<R1, R2>::type
{
};
template <class R1, class R2>
struct ratio_multiply
: boost::ratio_detail::ratio_multiply<R1, R2>::type
{
};
template <class R1, class R2>
struct ratio_divide
: boost::ratio_detail::ratio_divide<R1, R2>::type
{
};
//----------------------------------------------------------------------------//
// //
// 20.6.3 Comparision of ratio types [ratio.comparison] //
// //
//----------------------------------------------------------------------------//
// ratio_equal
template <class R1, class R2>
struct ratio_equal
: public boost::integral_constant<bool,
(R1::num == R2::num && R1::den == R2::den)>
{};
template <class R1, class R2>
struct ratio_not_equal
: public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
{};
// ratio_less
template <class R1, class R2>
struct ratio_less
: boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
{};
template <class R1, class R2>
struct ratio_less_equal
: boost::integral_constant<bool, !ratio_less<R2, R1>::value>
{};
template <class R1, class R2>
struct ratio_greater
: boost::integral_constant<bool, ratio_less<R2, R1>::value>
{};
template <class R1, class R2>
struct ratio_greater_equal
: boost::integral_constant<bool, !ratio_less<R1, R2>::value>
{};
template <class R1, class R2>
struct ratio_gcd :
ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
{
};
//----------------------------------------------------------------------------//
// //
// More arithmetic on ratio types [ratio.arithmetic] //
// //
//----------------------------------------------------------------------------//
#ifdef BOOST_RATIO_EXTENSIONS
template <class R>
struct ratio_negate
: ratio<-R::num, R::den>::type
{
};
template <class R>
struct ratio_abs
: ratio<mpl::abs_c<boost::intmax_t, R::num>::value, R::den>::type
{
};
template <class R>
struct ratio_sign
: mpl::sign_c<boost::intmax_t, R::num>
{
};
template <class R>
struct ratio_inverse
: ratio<R::den, R::num>::type
{
};
template <class R1, class R2>
struct ratio_lcm :
ratio<mpl::lcm_c<boost::intmax_t, R1::num, R2::num>::value,
mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value>::type
{
};
template <class R1, class R2>
struct ratio_modulo :
ratio<(R1::num * R2::den) % (R2::num * R1::den), R1::den * R2::den>::type
{
};
namespace detail {
template <class R1, class R2, bool r1ltr2>
struct ratio_min : R1 {};
template <class R1, class R2>
struct ratio_min<R1,R2,false> : R2 {};
template <class R1, class R2, bool r1ltr2>
struct ratio_max : R2 {};
template <class R1, class R2>
struct ratio_max<R1,R2,false> : R1 {};
}
template <class R1, class R2>
struct ratio_min : detail::ratio_min<R1, R2, ratio_less<R1,R2>::value>::type
{
};
template <class R1, class R2>
struct ratio_max : detail::ratio_max<R1, R2, ratio_less<R1,R2>::value>::type
{
};
template<typename R, int p>
struct ratio_power :
ratio_multiply<
typename ratio_power<R, p%2>::type,
typename ratio_power<typename ratio_multiply<R, R>::type, p/2>::type
>::type
{};
template<typename R>
struct ratio_power<R, 0> : ratio<1>::type {};
template<typename R>
struct ratio_power<R, 1> : R {};
template<typename R>
struct ratio_power<R, -1> : ratio_divide<ratio<1>, R>::type {};
#endif
} // namespace boost
#endif // BOOST_RATIO_RATIO_HPP

109
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/ratio_fwd.hpp vendored Executable file
View File

@@ -0,0 +1,109 @@
// ratio_fwd.hpp ---------------------------------------------------------------//
// Copyright 2008 Howard Hinnant
// Copyright 2008 Beman Dawes
// Copyright 2009 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
/*
This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype.
Many thanks to Howard for making his code available under the Boost license.
The original code was modified to conform to Boost conventions and to section
20.4 Compile-time rational arithmetic [ratio], of the C++ committee working
paper N2798.
See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf.
time2_demo contained this comment:
Much thanks to Andrei Alexandrescu,
Walter Brown,
Peter Dimov,
Jeff Garland,
Terry Golubiewski,
Daniel Krugler,
Anthony Williams.
*/
// The way overflow is managed for ratio_less is taken from llvm/libcxx/include/ratio
#ifndef BOOST_RATIO_RATIO_FWD_HPP
#define BOOST_RATIO_RATIO_FWD_HPP
#include <boost/ratio/config.hpp>
#if defined(__GNUC__) && (__GNUC__ >= 4)
#pragma GCC system_header
#endif
namespace boost
{
//----------------------------------------------------------------------------//
// //
// 20.6 Compile-time rational arithmetic [ratio] //
// //
//----------------------------------------------------------------------------//
// ratio
template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
// ratio arithmetic
template <class R1, class R2> struct ratio_add;
template <class R1, class R2> struct ratio_subtract;
template <class R1, class R2> struct ratio_multiply;
template <class R1, class R2> struct ratio_divide;
#ifdef BOOST_RATIO_EXTENSIONS
template <class R1, class R2> struct ratio_gcd;
template <class R1, class R2> struct ratio_lcm;
template <class R> struct ratio_negate;
template <class R> struct ratio_abs;
template <class R> struct ratio_sign;
template <class R, int P> struct ratio_power;
#endif
// ratio comparison
template <class R1, class R2> struct ratio_equal;
template <class R1, class R2> struct ratio_not_equal;
template <class R1, class R2> struct ratio_less;
template <class R1, class R2> struct ratio_less_equal;
template <class R1, class R2> struct ratio_greater;
template <class R1, class R2> struct ratio_greater_equal;
// convenience SI typedefs
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000000000000000)> atto;
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000000000000)> femto;
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000000000)> pico;
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000000)> nano;
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000000)> micro;
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(1000)> milli;
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(100)> centi;
typedef ratio<BOOST_RATIO_INTMAX_C(1), BOOST_RATIO_INTMAX_C(10)> deci;
typedef ratio< BOOST_RATIO_INTMAX_C(10), BOOST_RATIO_INTMAX_C(1)> deca;
typedef ratio< BOOST_RATIO_INTMAX_C(100), BOOST_RATIO_INTMAX_C(1)> hecto;
typedef ratio< BOOST_RATIO_INTMAX_C(1000), BOOST_RATIO_INTMAX_C(1)> kilo;
typedef ratio< BOOST_RATIO_INTMAX_C(1000000), BOOST_RATIO_INTMAX_C(1)> mega;
typedef ratio< BOOST_RATIO_INTMAX_C(1000000000), BOOST_RATIO_INTMAX_C(1)> giga;
typedef ratio< BOOST_RATIO_INTMAX_C(1000000000000), BOOST_RATIO_INTMAX_C(1)> tera;
typedef ratio< BOOST_RATIO_INTMAX_C(1000000000000000), BOOST_RATIO_INTMAX_C(1)> peta;
typedef ratio<BOOST_RATIO_INTMAX_C(1000000000000000000), BOOST_RATIO_INTMAX_C(1)> exa;
#ifdef BOOST_RATIO_EXTENSIONS
#define BOOST_RATIO_1024 BOOST_RATIO_INTMAX_C(1024)
// convenience IEC typedefs
typedef ratio< BOOST_RATIO_1024> kibi;
typedef ratio< BOOST_RATIO_1024*BOOST_RATIO_1024> mebi;
typedef ratio< BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> gibi;
typedef ratio< BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> tebi;
typedef ratio< BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> pebi;
typedef ratio<BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024*BOOST_RATIO_1024> exbi;
#endif
} // namespace boost
#endif // BOOST_RATIO_HPP

1076
externals/vcpkg/packages/boost-ratio_x64-windows/include/boost/ratio/ratio_io.hpp vendored Executable file
View File

File diff suppressed because it is too large Load Diff

23
externals/vcpkg/packages/boost-ratio_x64-windows/share/boost-ratio/copyright vendored Executable file
View File

@@ -0,0 +1,23 @@
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

4
externals/vcpkg/packages/boost-ratio_x64-windows/share/boost-ratio/usage vendored Executable file
View File

@@ -0,0 +1,4 @@
The package boost is compatible with built-in CMake targets:
find_package(Boost REQUIRED [COMPONENTS <libs>...])
target_link_libraries(main PRIVATE Boost::boost Boost::<lib1> Boost::<lib2> ...)

115
externals/vcpkg/packages/boost-ratio_x64-windows/share/boost-ratio/vcpkg.spdx.json vendored Executable file
View File

@@ -0,0 +1,115 @@
{
"$schema": "https://raw.githubusercontent.com/spdx/spdx-spec/v2.2.1/schemas/spdx-schema.json",
"spdxVersion": "SPDX-2.2",
"dataLicense": "CC0-1.0",
"SPDXID": "SPDXRef-DOCUMENT",
"documentNamespace": "https://spdx.org/spdxdocs/boost-ratio-x64-windows-1.79.0-196e93fe-fc1c-4301-897c-7a8efbb34d9a",
"name": "boost-ratio:x64-windows@1.79.0 2ff24914ebec67ffcef3caa61c2b8947741fbeaf9122e6efdce1ba4d778abe8e",
"creationInfo": {
"creators": [
"Tool: vcpkg-9268e366206712e38102b28dbd1617697a99ff2e"
],
"created": "2022-07-23T08:23:45Z"
},
"relationships": [
{
"spdxElementId": "SPDXRef-port",
"relationshipType": "GENERATES",
"relatedSpdxElement": "SPDXRef-binary"
},
{
"spdxElementId": "SPDXRef-port",
"relationshipType": "CONTAINS",
"relatedSpdxElement": "SPDXRef-file-0"
},
{
"spdxElementId": "SPDXRef-port",
"relationshipType": "CONTAINS",
"relatedSpdxElement": "SPDXRef-file-1"
},
{
"spdxElementId": "SPDXRef-binary",
"relationshipType": "GENERATED_FROM",
"relatedSpdxElement": "SPDXRef-port"
},
{
"spdxElementId": "SPDXRef-file-0",
"relationshipType": "CONTAINED_BY",
"relatedSpdxElement": "SPDXRef-port"
},
{
"spdxElementId": "SPDXRef-file-1",
"relationshipType": "CONTAINED_BY",
"relatedSpdxElement": "SPDXRef-port"
},
{
"spdxElementId": "SPDXRef-file-1",
"relationshipType": "DEPENDENCY_MANIFEST_OF",
"relatedSpdxElement": "SPDXRef-port"
}
],
"packages": [
{
"name": "boost-ratio",
"SPDXID": "SPDXRef-port",
"versionInfo": "1.79.0",
"downloadLocation": "NOASSERTION",
"homepage": "https://github.com/boostorg/ratio",
"licenseConcluded": "BSL-1.0",
"licenseDeclared": "NOASSERTION",
"copyrightText": "NOASSERTION",
"description": "Boost ratio module",
"comment": "This is the port (recipe) consumed by vcpkg."
},
{
"name": "boost-ratio:x64-windows",
"SPDXID": "SPDXRef-binary",
"versionInfo": "2ff24914ebec67ffcef3caa61c2b8947741fbeaf9122e6efdce1ba4d778abe8e",
"downloadLocation": "NONE",
"licenseConcluded": "BSL-1.0",
"licenseDeclared": "NOASSERTION",
"copyrightText": "NOASSERTION",
"comment": "This is a binary package built by vcpkg."
},
{
"SPDXID": "SPDXRef-resource-1",
"name": "boostorg/ratio",
"downloadLocation": "git+https://github.com/boostorg/ratio@boost-1.79.0",
"licenseConcluded": "NOASSERTION",
"licenseDeclared": "NOASSERTION",
"copyrightText": "NOASSERTION",
"checksums": [
{
"algorithm": "SHA512",
"checksumValue": "d3053b442cf2a00f0644d1f0ef438c6d2745edab3a6b0efe885e656c2072acbb09b69155bf7bf62a239820eddcecbb93be63c66864915a76bd169ec5916cdf7c"
}
]
}
],
"files": [
{
"fileName": "./portfile.cmake",
"SPDXID": "SPDXRef-file-0",
"checksums": [
{
"algorithm": "SHA256",
"checksumValue": "353eee64106c470f5c3104dc3be1b81ba8a70ba83c4d9f9e3bc4251f47752bfb"
}
],
"licenseConcluded": "NOASSERTION",
"copyrightText": "NOASSERTION"
},
{
"fileName": "./vcpkg.json",
"SPDXID": "SPDXRef-file-1",
"checksums": [
{
"algorithm": "SHA256",
"checksumValue": "734123df62b00dd73f521caff0007962a2ce627da73d6562c58310bd0ce2e717"
}
],
"licenseConcluded": "NOASSERTION",
"copyrightText": "NOASSERTION"
}
]
}

19
externals/vcpkg/packages/boost-ratio_x64-windows/share/boost-ratio/vcpkg_abi_info.txt vendored Executable file
View File

@@ -0,0 +1,19 @@
boost-config 797535e8975ed7cf5bbe11d9f7fe26caa5da8fe819888564758d82a21109fade
boost-core 498aea0b6b68bcfe1ec683e76c2f0d32477dfe9ba958f518980ff806b6faba90
boost-integer 7a387f2417014a6cf56a8a8cd689c8153efaaf93ea6beba8f390f5b9577da9cb
boost-mpl 89695bf75ab1fa2b706b2a0c2ef28c6726c3abd61ff51fb0966e3270153a6cd9
boost-rational 2e8a09e51f9381fb5738ee49e2c906c0235e6f318d6dda34ba6fb8a1f0afac17
boost-static-assert 795e87a155fce50821163bc84e802f28dce54e4af6a3a86045f9ecec76ad4c95
boost-type-traits 74f62124585467fbb6c4fa16015164d11e1a079d6bdb70ec1c3fe7cf65b9a594
boost-vcpkg-helpers c81c7b003df356a1a120a7c0c2f5a2ac95f3c33b006a2a5b4c02dcf0c9f3deaa
cmake 3.23.2
features core
portfile.cmake 353eee64106c470f5c3104dc3be1b81ba8a70ba83c4d9f9e3bc4251f47752bfb
ports.cmake 366c60b768113102408b32ac1d7c7b48ef7d30a477af2a220ecc222d9ffa3166
post_build_checks 2
powershell 7.2.5
triplet x64-windows
triplet_abi 4556164a2cd3dd6f4742101eabb46def7e71b6e5856faa88e5d005aac12a803c-c0600b35e024ce0485ed253ef5419f3686f7257cfb58cb6a24febcb600fc4b4c-27ebd443f77a6c449168adfa6ce8def60cf46e88
vcpkg.json 734123df62b00dd73f521caff0007962a2ce627da73d6562c58310bd0ce2e717
vcpkg_from_git 0aab20e34e84d52ba4763f009e539bfa8f418c41c918c8cf700156f1a8551a10
vcpkg_from_github b743742296a114ea1b18ae99672e02f142c4eb2bef7f57d36c038bedbfb0502f