ceph/src/boost/boost/geometry/algorithms/detail/within/interface.hpp

   1 // Boost.Geometry (aka GGL, Generic Geometry Library)
   2
   3 // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
   4 // Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
   5 // Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
   6
   7 // This file was modified by Oracle on 2013, 2014, 2017, 2018.
   8 // Modifications copyright (c) 2013-2018 Oracle and/or its affiliates.
   9
  10 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
  11
  12 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
  13 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
  14
  15 // Use, modification and distribution is subject to the Boost Software License,
  16 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  17 // http://www.boost.org/LICENSE_1_0.txt)
  18
  19 #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP
  20 #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP
  21
  22
  23 #include <boost/concept_check.hpp>
  24
  25 #include <boost/variant/apply_visitor.hpp>
  26 #include <boost/variant/static_visitor.hpp>
  27 #include <boost/variant/variant_fwd.hpp>
  28
  29 #include <boost/geometry/algorithms/not_implemented.hpp>
  30
  31 #include <boost/geometry/core/tag.hpp>
  32 #include <boost/geometry/core/tag_cast.hpp>
  33
  34 #include <boost/geometry/geometries/concepts/check.hpp>
  35 #include <boost/geometry/strategies/concepts/within_concept.hpp>
  36 #include <boost/geometry/strategies/default_strategy.hpp>
  37 #include <boost/geometry/strategies/within.hpp>
  38
  39
  40 namespace boost { namespace geometry
  41 {
  42
  43 #ifndef DOXYGEN_NO_DISPATCH
  44 namespace dispatch
  45 {
  46
  47 template
  48 <
  49     typename Geometry1,
  50     typename Geometry2,
  51     typename Tag1 = typename tag<Geometry1>::type,
  52     typename Tag2 = typename tag<Geometry2>::type
  53 >
  54 struct within
  55     : not_implemented<Tag1, Tag2>
  56 {};
  57
  58
  59 } // namespace dispatch
  60 #endif // DOXYGEN_NO_DISPATCH
  61
  62
  63 namespace resolve_strategy
  64 {
  65
  66 struct within
  67 {
  68     template <typename Geometry1, typename Geometry2, typename Strategy>
  69     static inline bool apply(Geometry1 const& geometry1,
  70                              Geometry2 const& geometry2,
  71                              Strategy const& strategy)
  72     {
  73         concepts::within::check<Geometry1, Geometry2, Strategy>();
  74
  75         return dispatch::within<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
  76     }
  77
  78     template <typename Geometry1, typename Geometry2>
  79     static inline bool apply(Geometry1 const& geometry1,
  80                              Geometry2 const& geometry2,
  81                              default_strategy)
  82     {
  83         typedef typename strategy::within::services::default_strategy
  84             <
  85                 Geometry1,
  86                 Geometry2
  87             >::type strategy_type;
  88
  89         return apply(geometry1, geometry2, strategy_type());
  90     }
  91 };
  92
  93 } // namespace resolve_strategy
  94
  95
  96 namespace resolve_variant
  97 {
  98
  99 template <typename Geometry1, typename Geometry2>
 100 struct within
 101 {
 102     template <typename Strategy>
 103     static inline bool apply(Geometry1 const& geometry1,
 104                              Geometry2 const& geometry2,
 105                              Strategy const& strategy)
 106     {
 107         concepts::check<Geometry1 const>();
 108         concepts::check<Geometry2 const>();
 109         assert_dimension_equal<Geometry1, Geometry2>();
 110
 111         return resolve_strategy::within::apply(geometry1,
 112                                                geometry2,
 113                                                strategy);
 114     }
 115 };
 116
 117 template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
 118 struct within<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
 119 {
 120     template <typename Strategy>
 121     struct visitor: boost::static_visitor<bool>
 122     {
 123         Geometry2 const& m_geometry2;
 124         Strategy const& m_strategy;
 125
 126         visitor(Geometry2 const& geometry2, Strategy const& strategy)
 127             : m_geometry2(geometry2)
 128             , m_strategy(strategy)
 129         {}
 130
 131         template <typename Geometry1>
 132         bool operator()(Geometry1 const& geometry1) const
 133         {
 134             return within<Geometry1, Geometry2>::apply(geometry1,
 135                                                        m_geometry2,
 136                                                        m_strategy);
 137         }
 138     };
 139
 140     template <typename Strategy>
 141     static inline bool
 142     apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
 143           Geometry2 const& geometry2,
 144           Strategy const& strategy)
 145     {
 146         return boost::apply_visitor(visitor<Strategy>(geometry2, strategy),
 147                                     geometry1);
 148     }
 149 };
 150
 151 template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
 152 struct within<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
 153 {
 154     template <typename Strategy>
 155     struct visitor: boost::static_visitor<bool>
 156     {
 157         Geometry1 const& m_geometry1;
 158         Strategy const& m_strategy;
 159
 160         visitor(Geometry1 const& geometry1, Strategy const& strategy)
 161             : m_geometry1(geometry1)
 162             , m_strategy(strategy)
 163         {}
 164
 165         template <typename Geometry2>
 166         bool operator()(Geometry2 const& geometry2) const
 167         {
 168             return within<Geometry1, Geometry2>::apply(m_geometry1,
 169                                                        geometry2,
 170                                                        m_strategy);
 171         }
 172     };
 173
 174     template <typename Strategy>
 175     static inline bool
 176     apply(Geometry1 const& geometry1,
 177           boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
 178           Strategy const& strategy)
 179     {
 180         return boost::apply_visitor(visitor<Strategy>(geometry1, strategy),
 181                                     geometry2
 182         );
 183     }
 184 };
 185
 186 template <
 187     BOOST_VARIANT_ENUM_PARAMS(typename T1),
 188     BOOST_VARIANT_ENUM_PARAMS(typename T2)
 189 >
 190 struct within<
 191     boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
 192     boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
 193 >
 194 {
 195     template <typename Strategy>
 196     struct visitor: boost::static_visitor<bool>
 197     {
 198         Strategy const& m_strategy;
 199
 200         visitor(Strategy const& strategy): m_strategy(strategy) {}
 201
 202         template <typename Geometry1, typename Geometry2>
 203         bool operator()(Geometry1 const& geometry1,
 204                         Geometry2 const& geometry2) const
 205         {
 206             return within<Geometry1, Geometry2>::apply(geometry1,
 207                                                        geometry2,
 208                                                        m_strategy);
 209         }
 210     };
 211
 212     template <typename Strategy>
 213     static inline bool
 214     apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
 215           boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
 216           Strategy const& strategy)
 217     {
 218         return boost::apply_visitor(visitor<Strategy>(strategy),
 219                                     geometry1,
 220                                     geometry2);
 221     }
 222 };
 223
 224 }
 225
 226
 227 /*!
 228 \brief \brief_check12{is completely inside}
 229 \ingroup within
 230 \details \details_check12{within, is completely inside}.
 231 \tparam Geometry1 \tparam_geometry
 232 \tparam Geometry2 \tparam_geometry
 233 \param geometry1 \param_geometry which might be within the second geometry
 234 \param geometry2 \param_geometry which might contain the first geometry
 235 \return true if geometry1 is completely contained within geometry2,
 236     else false
 237 \note The default strategy is used for within detection
 238
 239
 240 \qbk{[include reference/algorithms/within.qbk]}
 241
 242 \qbk{
 243 [heading Example]
 244 [within]
 245 [within_output]
 246 }
 247  */
 248 template<typename Geometry1, typename Geometry2>
 249 inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2)
 250 {
 251     return resolve_variant::within
 252         <
 253             Geometry1,
 254             Geometry2
 255         >::apply(geometry1, geometry2, default_strategy());
 256 }
 257
 258 /*!
 259 \brief \brief_check12{is completely inside} \brief_strategy
 260 \ingroup within
 261 \details \details_check12{within, is completely inside}, \brief_strategy. \details_strategy_reasons
 262 \tparam Geometry1 \tparam_geometry
 263 \tparam Geometry2 \tparam_geometry
 264 \param geometry1 \param_geometry which might be within the second geometry
 265 \param geometry2 \param_geometry which might contain the first geometry
 266 \param strategy strategy to be used
 267 \return true if geometry1 is completely contained within geometry2,
 268     else false
 269
 270 \qbk{distinguish,with strategy}
 271 \qbk{[include reference/algorithms/within.qbk]}
 272 \qbk{
 273 [heading Available Strategies]
 274 \* [link geometry.reference.strategies.strategy_within_winding Winding (coordinate system agnostic)]
 275 \* [link geometry.reference.strategies.strategy_within_franklin Franklin (cartesian)]
 276 \* [link geometry.reference.strategies.strategy_within_crossings_multiply Crossings Multiply (cartesian)]
 277
 278 [heading Example]
 279 [within_strategy]
 280 [within_strategy_output]
 281
 282 }
 283 */
 284 template<typename Geometry1, typename Geometry2, typename Strategy>
 285 inline bool within(Geometry1 const& geometry1,
 286                    Geometry2 const& geometry2,
 287                    Strategy const& strategy)
 288 {
 289     return resolve_variant::within
 290         <
 291             Geometry1,
 292             Geometry2
 293         >::apply(geometry1, geometry2, strategy);
 294 }
 295
 296 }} // namespace boost::geometry
 297
 298 #endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP