ceph/src/boost/boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp

   1 // Boost.Geometry (aka GGL, Generic Geometry Library)
   2
   3 // Copyright (c) 2014-2020, Oracle and/or its affiliates.
   4
   5 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
   6 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
   7
   8 // Licensed under the Boost Software License version 1.0.
   9 // http://www.boost.org/users/license.html
  10
  11 #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_INVALID_COORDINATE_HPP
  12 #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_INVALID_COORDINATE_HPP
  13
  14 #include <cstddef>
  15 #include <type_traits>
  16
  17 #include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
  18 #include <boost/geometry/algorithms/validity_failure_type.hpp>
  19
  20 #include <boost/geometry/core/coordinate_type.hpp>
  21 #include <boost/geometry/core/point_type.hpp>
  22
  23 #include <boost/geometry/iterators/point_iterator.hpp>
  24
  25 #include <boost/geometry/views/detail/indexed_point_view.hpp>
  26
  27 #include <boost/geometry/util/has_non_finite_coordinate.hpp>
  28
  29 namespace boost { namespace geometry
  30 {
  31
  32 #ifndef DOXYGEN_NO_DETAIL
  33 namespace detail { namespace is_valid
  34 {
  35
  36 struct always_valid
  37 {
  38     template <typename Geometry, typename VisitPolicy>
  39     static inline bool apply(Geometry const&, VisitPolicy& visitor)
  40     {
  41         return ! visitor.template apply<no_failure>();
  42     }
  43 };
  44
  45 struct point_has_invalid_coordinate
  46 {
  47     template <typename Point, typename VisitPolicy>
  48     static inline bool apply(Point const& point, VisitPolicy& visitor)
  49     {
  50         boost::ignore_unused(visitor);
  51
  52         return
  53             geometry::has_non_finite_coordinate(point)
  54             ?
  55             (! visitor.template apply<failure_invalid_coordinate>())
  56             :
  57             (! visitor.template apply<no_failure>());
  58     }
  59
  60     template <typename Point>
  61     static inline bool apply(Point const& point)
  62     {
  63         return geometry::has_non_finite_coordinate(point);
  64     }
  65 };
  66
  67 struct indexed_has_invalid_coordinate
  68 {
  69     template <typename Geometry, typename VisitPolicy>
  70     static inline bool apply(Geometry const& geometry, VisitPolicy& visitor)
  71     {
  72         geometry::detail::indexed_point_view<Geometry const, 0> p0(geometry);
  73         geometry::detail::indexed_point_view<Geometry const, 1> p1(geometry);
  74
  75         return point_has_invalid_coordinate::apply(p0, visitor)
  76             || point_has_invalid_coordinate::apply(p1, visitor);
  77     }
  78 };
  79
  80
  81 struct range_has_invalid_coordinate
  82 {
  83     struct point_has_valid_coordinates
  84     {
  85         template <typename Point>
  86         static inline bool apply(Point const& point)
  87         {
  88             return ! point_has_invalid_coordinate::apply(point);
  89         }
  90     };
  91
  92     template <typename Geometry, typename VisitPolicy>
  93     static inline bool apply(Geometry const& geometry, VisitPolicy& visitor)
  94     {
  95         boost::ignore_unused(visitor);
  96
  97         bool const has_valid_coordinates = detail::check_iterator_range
  98             <
  99                 point_has_valid_coordinates,
 100                 true // do not consider an empty range as problematic
 101             >::apply(geometry::points_begin(geometry),
 102                      geometry::points_end(geometry));
 103
 104         return has_valid_coordinates
 105             ?
 106             (! visitor.template apply<no_failure>())
 107             :
 108             (! visitor.template apply<failure_invalid_coordinate>());
 109     }
 110 };
 111
 112
 113 template
 114 <
 115     typename Geometry,
 116     typename Tag = typename tag<Geometry>::type,
 117     bool HasFloatingPointCoordinates = std::is_floating_point
 118         <
 119             typename coordinate_type<Geometry>::type
 120         >::value
 121 >
 122 struct has_invalid_coordinate
 123     : range_has_invalid_coordinate
 124 {};
 125
 126 template <typename Geometry, typename Tag>
 127 struct has_invalid_coordinate<Geometry, Tag, false>
 128     : always_valid
 129 {};
 130
 131 template <typename Point>
 132 struct has_invalid_coordinate<Point, point_tag, true>
 133     : point_has_invalid_coordinate
 134 {};
 135
 136 template <typename Segment>
 137 struct has_invalid_coordinate<Segment, segment_tag, true>
 138     : indexed_has_invalid_coordinate
 139 {};
 140
 141 template <typename Box>
 142 struct has_invalid_coordinate<Box, box_tag, true>
 143     : indexed_has_invalid_coordinate
 144 {};
 145
 146
 147 }} // namespace detail::is_valid
 148 #endif // DOXYGEN_NO_DETAIL
 149
 150 }} // namespace boost::geometry
 151
 152 #endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_INVALID_COORDINATE_HPP