ceph/src/boost/boost/geometry/core/radius.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 2014.
   8 // Modifications copyright (c) 2014 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
  20 #ifndef BOOST_GEOMETRY_CORE_RADIUS_HPP
  21 #define BOOST_GEOMETRY_CORE_RADIUS_HPP
  22
  23
  24 #include <cstddef>
  25
  26 #include <boost/static_assert.hpp>
  27 #include <boost/type_traits/is_pointer.hpp>
  28
  29 #include <boost/geometry/core/tag.hpp>
  30 #include <boost/geometry/core/tags.hpp>
  31 #include <boost/geometry/util/bare_type.hpp>
  32
  33
  34 namespace boost { namespace geometry
  35 {
  36
  37 namespace traits
  38 {
  39
  40 /*!
  41     \brief Traits class to get/set radius of a circle/sphere/(ellipse)
  42     \details the radius access meta-functions give read/write access to the radius of a circle or a sphere,
  43     or to the major/minor axis or an ellipse, or to one of the 3 equatorial radii of an ellipsoid.
  44
  45     It should be specialized per geometry, in namespace core_dispatch. Those specializations should
  46     forward the call via traits to the geometry class, which could be specified by the user.
  47
  48     There is a corresponding generic radius_get and radius_set function
  49     \par Geometries:
  50         - n-sphere (circle,sphere)
  51         - upcoming ellipse
  52     \par Specializations should provide:
  53         - inline static T get(Geometry const& geometry)
  54         - inline static void set(Geometry& geometry, T const& radius)
  55     \ingroup traits
  56 */
  57 template <typename Geometry, std::size_t Dimension>
  58 struct radius_access {};
  59
  60
  61 /*!
  62     \brief Traits class indicating the type (double,float,...) of the radius of a circle or a sphere
  63     \par Geometries:
  64         - n-sphere (circle,sphere)
  65         - upcoming ellipse
  66     \par Specializations should provide:
  67         - typedef T type (double,float,int,etc)
  68     \ingroup traits
  69 */
  70 template <typename Geometry>
  71 struct radius_type {};
  72
  73 } // namespace traits
  74
  75
  76 #ifndef DOXYGEN_NO_DISPATCH
  77 namespace core_dispatch
  78 {
  79
  80 template <typename Tag, typename Geometry>
  81 struct radius_type
  82 {
  83     //typedef core_dispatch_specialization_required type;
  84 };
  85
  86 /*!
  87     \brief radius access meta-functions, used by concept n-sphere and upcoming ellipse.
  88 */
  89 template <typename Tag,
  90           typename Geometry,
  91           std::size_t Dimension,
  92           typename IsPointer>
  93 struct radius_access
  94 {
  95     //static inline CoordinateType get(Geometry const& ) {}
  96     //static inline void set(Geometry& g, CoordinateType const& value) {}
  97 };
  98
  99 } // namespace core_dispatch
 100 #endif // DOXYGEN_NO_DISPATCH
 101
 102
 103 /*!
 104     \brief Metafunction to get the type of radius of a circle / sphere / ellipse / etc.
 105     \ingroup access
 106     \tparam Geometry the type of geometry
 107 */
 108 template <typename Geometry>
 109 struct radius_type
 110 {
 111     typedef typename core_dispatch::radius_type
 112                         <
 113                             typename tag<Geometry>::type,
 114                             typename util::bare_type<Geometry>::type
 115                         >::type type;
 116 };
 117
 118 /*!
 119     \brief Function to get radius of a circle / sphere / ellipse / etc.
 120     \return radius The radius for a given axis
 121     \ingroup access
 122     \param geometry the geometry to get the radius from
 123     \tparam I index of the axis
 124 */
 125 template <std::size_t I, typename Geometry>
 126 inline typename radius_type<Geometry>::type get_radius(Geometry const& geometry)
 127 {
 128     return core_dispatch::radius_access
 129             <
 130                 typename tag<Geometry>::type,
 131                 typename util::bare_type<Geometry>::type,
 132                 I,
 133                 typename boost::is_pointer<Geometry>::type
 134             >::get(geometry);
 135 }
 136
 137 /*!
 138     \brief Function to set the radius of a circle / sphere / ellipse / etc.
 139     \ingroup access
 140     \tparam I index of the axis
 141     \param geometry the geometry to change
 142     \param radius the radius to set
 143 */
 144 template <std::size_t I, typename Geometry>
 145 inline void set_radius(Geometry& geometry,
 146                        typename radius_type<Geometry>::type const& radius)
 147 {
 148     core_dispatch::radius_access
 149         <
 150             typename tag<Geometry>::type,
 151             typename util::bare_type<Geometry>::type,
 152             I,
 153             typename boost::is_pointer<Geometry>::type
 154         >::set(geometry, radius);
 155 }
 156
 157
 158
 159 #ifndef DOXYGEN_NO_DETAIL
 160 namespace detail
 161 {
 162
 163 template <typename Tag, typename Geometry, std::size_t Dimension>
 164 struct radius_access
 165 {
 166     static inline typename radius_type<Geometry>::type get(Geometry const& geometry)
 167     {
 168         return traits::radius_access<Geometry, Dimension>::get(geometry);
 169     }
 170     static inline void set(Geometry& geometry,
 171                            typename radius_type<Geometry>::type const& value)
 172     {
 173         traits::radius_access<Geometry, Dimension>::set(geometry, value);
 174     }
 175 };
 176
 177 } // namespace detail
 178 #endif // DOXYGEN_NO_DETAIL
 179
 180
 181 #ifndef DOXYGEN_NO_DISPATCH
 182 namespace core_dispatch
 183 {
 184
 185 template <typename Tag,
 186           typename Geometry,
 187           std::size_t Dimension>
 188 struct radius_access<Tag, Geometry, Dimension, boost::true_type>
 189 {
 190     typedef typename geometry::radius_type<Geometry>::type radius_type;
 191
 192     static inline radius_type get(const Geometry * geometry)
 193     {
 194         return radius_access
 195                 <
 196                     Tag,
 197                     Geometry,
 198                     Dimension,
 199                     typename boost::is_pointer<Geometry>::type
 200                 >::get(*geometry);
 201     }
 202
 203     static inline void set(Geometry * geometry, radius_type const& value)
 204     {
 205         return radius_access
 206                 <
 207                     Tag,
 208                     Geometry,
 209                     Dimension,
 210                     typename boost::is_pointer<Geometry>::type
 211                 >::set(*geometry, value);
 212     }
 213 };
 214
 215
 216 template <typename Geometry>
 217 struct radius_type<srs_sphere_tag, Geometry>
 218 {
 219     typedef typename traits::radius_type<Geometry>::type type;
 220 };
 221
 222 template <typename Geometry, std::size_t Dimension>
 223 struct radius_access<srs_sphere_tag, Geometry, Dimension, boost::false_type>
 224     : detail::radius_access<srs_sphere_tag, Geometry, Dimension>
 225 {
 226     BOOST_STATIC_ASSERT(Dimension == 0);
 227     //BOOST_STATIC_ASSERT(Dimension < 3);
 228 };
 229
 230 template <typename Geometry>
 231 struct radius_type<srs_spheroid_tag, Geometry>
 232 {
 233     typedef typename traits::radius_type<Geometry>::type type;
 234 };
 235
 236 template <typename Geometry, std::size_t Dimension>
 237 struct radius_access<srs_spheroid_tag, Geometry, Dimension, boost::false_type>
 238     : detail::radius_access<srs_spheroid_tag, Geometry, Dimension>
 239 {
 240     BOOST_STATIC_ASSERT(Dimension == 0 || Dimension == 2);
 241     //BOOST_STATIC_ASSERT(Dimension < 3);
 242 };
 243
 244 } // namespace core_dispatch
 245 #endif // DOXYGEN_NO_DISPATCH
 246
 247
 248 }} // namespace boost::geometry
 249
 250
 251 #endif // BOOST_GEOMETRY_CORE_RADIUS_HPP