update boost

This commit is contained in:
2023-11-24 12:56:13 -06:00
parent cfc99971af
commit 19d727037a
9260 changed files with 849256 additions and 299957 deletions

View File

@@ -0,0 +1,79 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_CARTESIAN_HPP
#define BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_CARTESIAN_HPP
#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
#include <boost/geometry/strategies/detail.hpp>
#include <boost/geometry/strategies/discrete_distance/services.hpp>
#include <boost/geometry/strategies/distance/comparable.hpp>
#include <boost/geometry/strategies/distance/detail.hpp>
#include <boost/geometry/util/type_traits.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace discrete_distance
{
template <typename CalculationType = void>
struct cartesian
: public strategies::detail::cartesian_base
{
template <typename Geometry1, typename Geometry2>
static auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_pp_t<Geometry1, Geometry2> * = nullptr)
{
return strategy::distance::pythagoras<CalculationType>();
}
};
namespace services
{
template <typename Geometry1, typename Geometry2>
struct default_strategy<Geometry1, Geometry2, cartesian_tag, cartesian_tag>
{
using type = strategies::discrete_distance::cartesian<>;
};
template <typename CT>
struct strategy_converter<strategy::distance::pythagoras<CT> >
{
static auto get(strategy::distance::pythagoras<CT> const&)
{
return strategies::discrete_distance::cartesian<CT>();
}
};
template <typename CT>
struct strategy_converter<strategy::distance::comparable::pythagoras<CT> >
{
static auto get(strategy::distance::comparable::pythagoras<CT> const&)
{
return strategies::distance::detail::make_comparable(
strategies::discrete_distance::cartesian<CT>());
}
};
} // namespace services
}} // namespace strategies::discrete_distance
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_CARTESIAN_HPP

View File

@@ -0,0 +1,115 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_GEOGRAPHIC_HPP
#define BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_GEOGRAPHIC_HPP
#include <boost/geometry/strategies/detail.hpp>
#include <boost/geometry/strategies/discrete_distance/services.hpp>
#include <boost/geometry/strategies/distance/comparable.hpp>
#include <boost/geometry/strategies/distance/detail.hpp>
#include <boost/geometry/strategies/geographic/distance.hpp>
// TODO - for backwards compatibility, remove?
#include <boost/geometry/strategies/geographic/distance_andoyer.hpp>
#include <boost/geometry/strategies/geographic/distance_thomas.hpp>
#include <boost/geometry/strategies/geographic/distance_vincenty.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace discrete_distance
{
template
<
typename FormulaPolicy = strategy::andoyer,
typename Spheroid = srs::spheroid<double>,
typename CalculationType = void
>
class geographic
: public strategies::detail::geographic_base<Spheroid>
{
using base_t = strategies::detail::geographic_base<Spheroid>;
public:
geographic() = default;
explicit geographic(Spheroid const& spheroid)
: base_t(spheroid)
{}
template <typename Geometry1, typename Geometry2>
auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_pp_t<Geometry1, Geometry2> * = nullptr) const
{
return strategy::distance::geographic
<
FormulaPolicy, Spheroid, CalculationType
>(base_t::m_spheroid);
}
};
namespace services
{
template <typename Geometry1, typename Geometry2>
struct default_strategy<Geometry1, Geometry2, geographic_tag, geographic_tag>
{
using type = strategies::discrete_distance::geographic<>;
};
template <typename FP, typename S, typename CT>
struct strategy_converter<strategy::distance::geographic<FP, S, CT> >
{
static auto get(strategy::distance::geographic<FP, S, CT> const& s)
{
return strategies::discrete_distance::geographic<FP, S, CT>(s.model());
}
};
// TODO - for backwards compatibility, remove?
template <typename S, typename CT>
struct strategy_converter<strategy::distance::andoyer<S, CT> >
{
static auto get(strategy::distance::andoyer<S, CT> const& s)
{
return strategies::discrete_distance::geographic<strategy::andoyer, S, CT>(s.model());
}
};
// TODO - for backwards compatibility, remove?
template <typename S, typename CT>
struct strategy_converter<strategy::distance::thomas<S, CT> >
{
static auto get(strategy::distance::thomas<S, CT> const& s)
{
return strategies::discrete_distance::geographic<strategy::thomas, S, CT>(s.model());
}
};
// TODO - for backwards compatibility, remove?
template <typename S, typename CT>
struct strategy_converter<strategy::distance::vincenty<S, CT> >
{
static auto get(strategy::distance::vincenty<S, CT> const& s)
{
return strategies::discrete_distance::geographic<strategy::vincenty, S, CT>(s.model());
}
};
} // namespace services
}} // namespace strategies::discrete_distance
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_GEOGRAPHIC_HPP

View File

@@ -0,0 +1,56 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_SERVICES_HPP
#define BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_SERVICES_HPP
#include <boost/geometry/core/cs.hpp>
#include <boost/geometry/core/static_assert.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace discrete_distance
{
namespace services
{
template
<
typename Geometry1,
typename Geometry2,
typename CSTag1 = typename geometry::cs_tag<Geometry1>::type,
typename CSTag2 = typename geometry::cs_tag<Geometry2>::type
>
struct default_strategy
{
BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
"Not implemented for these Geometries' coordinate systems.",
Geometry1, Geometry2, CSTag1, CSTag2);
};
template <typename Strategy>
struct strategy_converter
{
BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
"Not implemented for this Strategy.",
Strategy);
};
} // namespace services
}} // namespace strategies::discrete_distance
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_SERVICES_HPP

View File

@@ -0,0 +1,93 @@
// Boost.Geometry
// Copyright (c) 2021, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html
#ifndef BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_SPHERICAL_HPP
#define BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_SPHERICAL_HPP
#include <boost/geometry/strategies/detail.hpp>
#include <boost/geometry/strategies/discrete_distance/services.hpp>
#include <boost/geometry/strategies/distance/comparable.hpp>
#include <boost/geometry/strategies/distance/detail.hpp>
#include <boost/geometry/strategies/spherical/distance_haversine.hpp>
namespace boost { namespace geometry
{
namespace strategies { namespace discrete_distance
{
template
<
typename RadiusTypeOrSphere = double,
typename CalculationType = void
>
class spherical
: public strategies::detail::spherical_base<RadiusTypeOrSphere>
{
using base_t = strategies::detail::spherical_base<RadiusTypeOrSphere>;
public:
spherical() = default;
template <typename RadiusOrSphere>
explicit spherical(RadiusOrSphere const& radius_or_sphere)
: base_t(radius_or_sphere)
{}
template <typename Geometry1, typename Geometry2>
auto distance(Geometry1 const&, Geometry2 const&,
distance::detail::enable_if_pp_t<Geometry1, Geometry2> * = nullptr) const
{
return strategy::distance::haversine
<
typename base_t::radius_type, CalculationType
>(base_t::radius());
}
};
namespace services
{
template <typename Geometry1, typename Geometry2>
struct default_strategy<Geometry1, Geometry2, spherical_equatorial_tag, spherical_equatorial_tag>
{
using type = strategies::discrete_distance::spherical<>;
};
template <typename R, typename CT>
struct strategy_converter<strategy::distance::haversine<R, CT> >
{
static auto get(strategy::distance::haversine<R, CT> const& s)
{
return strategies::discrete_distance::spherical<R, CT>(s.radius());
}
};
template <typename R, typename CT>
struct strategy_converter<strategy::distance::comparable::haversine<R, CT> >
{
static auto get(strategy::distance::comparable::haversine<R, CT> const& s)
{
return strategies::distance::detail::make_comparable(
strategies::discrete_distance::spherical<R, CT>(s.radius()));
}
};
} // namespace services
}} // namespace strategies::discrete_distance
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_STRATEGIES_DISCRETE_DISTANCE_SPHERICAL_HPP