Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r84038 - in trunk/boost/geometry: algorithms algorithms/detail algorithms/detail/overlay core iterators policies/relate strategies strategies/agnostic util
From: adam.wulkiewicz_at_[hidden]
Date: 2013-04-24 10:22:23


Author: awulkiew
Date: 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
New Revision: 84038
URL: http://svn.boost.org/trac/boost/changeset/84038

Log:
geometry: tabs replaced by spaces in non-extensions code.
Text files modified:
   trunk/boost/geometry/algorithms/detail/occupation_info.hpp | 186 ++++++++++++++++++++--------------------
   trunk/boost/geometry/algorithms/detail/overlay/calculate_distance_policy.hpp | 14 +-
   trunk/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp | 108 +++++++++++-----------
   trunk/boost/geometry/algorithms/disjoint.hpp | 14 +-
   trunk/boost/geometry/algorithms/for_each.hpp | 18 +-
   trunk/boost/geometry/core/access.hpp | 14 +-
   trunk/boost/geometry/core/coordinate_dimension.hpp | 2
   trunk/boost/geometry/core/coordinate_system.hpp | 8
   trunk/boost/geometry/core/coordinate_type.hpp | 14 +-
   trunk/boost/geometry/core/tag.hpp | 2
   trunk/boost/geometry/iterators/ever_circling_iterator.hpp | 2
   trunk/boost/geometry/policies/relate/direction.hpp | 4
   trunk/boost/geometry/policies/relate/intersection_points.hpp | 4
   trunk/boost/geometry/policies/relate/tupled.hpp | 4
   trunk/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp | 8
   trunk/boost/geometry/strategies/side_info.hpp | 2
   trunk/boost/geometry/strategies/strategy_transform.hpp | 44 ++++----
   trunk/boost/geometry/util/math.hpp | 26 ++--
   trunk/boost/geometry/util/rational.hpp | 24 ++--
   19 files changed, 249 insertions(+), 249 deletions(-)

Modified: trunk/boost/geometry/algorithms/detail/occupation_info.hpp
==============================================================================
--- trunk/boost/geometry/algorithms/detail/occupation_info.hpp (original)
+++ trunk/boost/geometry/algorithms/detail/occupation_info.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -91,26 +91,26 @@
 template <typename Iterator, typename Vector>
 inline Iterator advance_circular(Iterator it, Vector const& vector, segment_identifier& seg_id, bool forward = true)
 {
- int const increment = forward ? 1 : -1;
- if (it == boost::begin(vector) && increment < 0)
- {
- it = boost::end(vector);
+ int const increment = forward ? 1 : -1;
+ if (it == boost::begin(vector) && increment < 0)
+ {
+ it = boost::end(vector);
         seg_id.segment_index = boost::size(vector);
- }
- it += increment;
+ }
+ it += increment;
     seg_id.segment_index += increment;
- if (it == boost::end(vector))
- {
+ if (it == boost::end(vector))
+ {
         seg_id.segment_index = 0;
- it = boost::begin(vector);
- }
- return it;
+ it = boost::begin(vector);
+ }
+ return it;
 }
 
 template <typename Point, typename T>
 struct angle_info
 {
- typedef T angle_type;
+ typedef T angle_type;
     typedef Point point_type;
 
     segment_identifier seg_id;
@@ -125,70 +125,70 @@
 template <typename AngleInfo>
 class occupation_info
 {
- typedef std::vector<AngleInfo> collection_type;
+ typedef std::vector<AngleInfo> collection_type;
 
- struct angle_sort
- {
- inline bool operator()(AngleInfo const& left, AngleInfo const& right) const
- {
- // In this case we can compare even double using equals
- // return geometry::math::equals(left.angle, right.angle)
- return left.angle == right.angle
- ? int(left.incoming) < int(right.incoming)
- : left.angle < right.angle
- ;
- }
- };
+ struct angle_sort
+ {
+ inline bool operator()(AngleInfo const& left, AngleInfo const& right) const
+ {
+ // In this case we can compare even double using equals
+ // return geometry::math::equals(left.angle, right.angle)
+ return left.angle == right.angle
+ ? int(left.incoming) < int(right.incoming)
+ : left.angle < right.angle
+ ;
+ }
+ };
 
 public :
     collection_type angles;
 private :
     bool m_occupied;
- bool m_calculated;
+ bool m_calculated;
 
- inline bool is_occupied()
- {
- if (boost::size(angles) <= 1)
- {
- return false;
- }
-
- std::sort(angles.begin(), angles.end(), angle_sort());
-
- typedef geometry::closing_iterator<collection_type const> closing_iterator;
- closing_iterator vit(angles);
- closing_iterator end(angles, true);
-
- closing_iterator prev = vit++;
- for( ; vit != end; prev = vit++)
- {
- if (! geometry::math::equals(prev->angle, vit->angle)
- && ! prev->incoming
- && vit->incoming)
- {
- return false;
- }
- }
- return true;
- }
+ inline bool is_occupied()
+ {
+ if (boost::size(angles) <= 1)
+ {
+ return false;
+ }
+
+ std::sort(angles.begin(), angles.end(), angle_sort());
+
+ typedef geometry::closing_iterator<collection_type const> closing_iterator;
+ closing_iterator vit(angles);
+ closing_iterator end(angles, true);
+
+ closing_iterator prev = vit++;
+ for( ; vit != end; prev = vit++)
+ {
+ if (! geometry::math::equals(prev->angle, vit->angle)
+ && ! prev->incoming
+ && vit->incoming)
+ {
+ return false;
+ }
+ }
+ return true;
+ }
 
 public :
     inline occupation_info()
         : m_occupied(false)
- , m_calculated(false)
+ , m_calculated(false)
     {}
 
- template <typename PointC, typename Point1, typename Point2>
- inline void add(PointC const& map_point, Point1 const& direction_point, Point2 const& intersection_point,
+ template <typename PointC, typename Point1, typename Point2>
+ inline void add(PointC const& map_point, Point1 const& direction_point, Point2 const& intersection_point,
                     int turn_index, int operation_index,
                     segment_identifier const& seg_id, bool incoming)
- {
+ {
         //std::cout << "-> adding angle " << geometry::wkt(direction_point) << " .. " << geometry::wkt(intersection_point) << " " << int(incoming) << std::endl;
- if (geometry::equals(direction_point, intersection_point))
- {
- //std::cout << "EQUAL! Skipping" << std::endl;
- return;
- }
+ if (geometry::equals(direction_point, intersection_point))
+ {
+ //std::cout << "EQUAL! Skipping" << std::endl;
+ return;
+ }
 
         AngleInfo info;
         info.incoming = incoming;
@@ -200,18 +200,18 @@
         info.direction_point = direction_point;
         angles.push_back(info);
 
- m_calculated = false;
- }
+ m_calculated = false;
+ }
 
- inline bool occupied()
- {
- if (! m_calculated)
- {
- m_occupied = is_occupied();
- m_calculated = true;
- }
- return m_occupied;
- }
+ inline bool occupied()
+ {
+ if (! m_calculated)
+ {
+ m_occupied = is_occupied();
+ m_calculated = true;
+ }
+ return m_occupied;
+ }
 
     template <typename Turns, typename TurnSegmentIndices>
     inline void get_left_turns(
@@ -226,7 +226,7 @@
 
 template <typename Point, typename Ring, typename Info>
 inline void add_incoming_and_outgoing_angles(Point const& map_point, Point const& intersection_point,
- Ring const& ring,
+ Ring const& ring,
                 int turn_index,
                 int operation_index,
                 segment_identifier seg_id,
@@ -237,43 +237,43 @@
             Ring const
>::type iterator_type;
 
- int const n = boost::size(ring);
- if (seg_id.segment_index >= n || seg_id.segment_index < 0)
- {
- return;
- }
+ int const n = boost::size(ring);
+ if (seg_id.segment_index >= n || seg_id.segment_index < 0)
+ {
+ return;
+ }
 
     segment_identifier real_seg_id = seg_id;
- iterator_type it = boost::begin(ring) + seg_id.segment_index;
+ iterator_type it = boost::begin(ring) + seg_id.segment_index;
 
     // TODO: if we use turn-info ("to", "middle"), we know if to advance without resorting to equals
     relaxed_less<Point> comparator;
 
     if (comparator.equals(intersection_point, *it))
     {
- // It should be equal only once. But otherwise we skip it (in "add")
- it = advance_circular(it, ring, seg_id, false);
+ // It should be equal only once. But otherwise we skip it (in "add")
+ it = advance_circular(it, ring, seg_id, false);
     }
 
- info.add(map_point, *it, intersection_point, turn_index, operation_index, real_seg_id, true);
+ info.add(map_point, *it, intersection_point, turn_index, operation_index, real_seg_id, true);
 
     if (comparator.equals(intersection_point, *it))
     {
- it = advance_circular(it, ring, real_seg_id);
- }
- else
- {
- // Don't upgrade the ID
- it = advance_circular(it, ring, seg_id);
- }
+ it = advance_circular(it, ring, real_seg_id);
+ }
+ else
+ {
+ // Don't upgrade the ID
+ it = advance_circular(it, ring, seg_id);
+ }
     for (int defensive_check = 0;
- comparator.equals(intersection_point, *it) && defensive_check < n;
- defensive_check++)
+ comparator.equals(intersection_point, *it) && defensive_check < n;
+ defensive_check++)
     {
- it = advance_circular(it, ring, real_seg_id);
+ it = advance_circular(it, ring, real_seg_id);
     }
 
- info.add(map_point, *it, intersection_point, turn_index, operation_index, real_seg_id, false);
+ info.add(map_point, *it, intersection_point, turn_index, operation_index, real_seg_id, false);
 }
 
 
@@ -287,7 +287,7 @@
     typedef std::map<Point, OccupationInfo, relaxed_less<Point> > map_type;
 
     map_type map;
- std::set<int> turn_indices;
+ std::set<int> turn_indices;
 
     inline OccupationInfo& find_or_insert(Point const& point, Point& mapped_point)
     {

Modified: trunk/boost/geometry/algorithms/detail/overlay/calculate_distance_policy.hpp
==============================================================================
--- trunk/boost/geometry/algorithms/detail/overlay/calculate_distance_policy.hpp (original)
+++ trunk/boost/geometry/algorithms/detail/overlay/calculate_distance_policy.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -35,13 +35,13 @@
     static bool const include_opposite = false;
 
     template
- <
- typename Info,
- typename Point1,
- typename Point2,
- typename IntersectionInfo,
- typename DirInfo
- >
+ <
+ typename Info,
+ typename Point1,
+ typename Point2,
+ typename IntersectionInfo,
+ typename DirInfo
+ >
     static inline void apply(Info& info, Point1 const& p1, Point2 const& p2,
                 IntersectionInfo const&, DirInfo const&)
     {

Modified: trunk/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp
==============================================================================
--- trunk/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp (original)
+++ trunk/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -492,26 +492,26 @@
         typename DirInfo
>
     static inline void apply(Point1 const& pi, Point2 const& qi,
- /* by value: */ TurnInfo tp,
+ /* by value: */ TurnInfo tp,
                 OutputIterator& out,
                 IntersectionInfo const& intersection_info,
                 DirInfo const& dir_info)
     {
         // For equal-opposite segments, normally don't do anything.
- if (AssignPolicy::include_opposite)
- {
- tp.method = method_equal;
- for (int i = 0; i < 2; i++)
- {
- tp.operations[i].operation = operation_opposite;
- }
- for (unsigned int i = 0; i < intersection_info.count; i++)
- {
- geometry::convert(intersection_info.intersections[i], tp.point);
- AssignPolicy::apply(tp, pi, qi, intersection_info, dir_info);
- *out++ = tp;
- }
- }
+ if (AssignPolicy::include_opposite)
+ {
+ tp.method = method_equal;
+ for (int i = 0; i < 2; i++)
+ {
+ tp.operations[i].operation = operation_opposite;
+ }
+ for (unsigned int i = 0; i < intersection_info.count; i++)
+ {
+ geometry::convert(intersection_info.intersections[i], tp.point);
+ AssignPolicy::apply(tp, pi, qi, intersection_info, dir_info);
+ *out++ = tp;
+ }
+ }
     }
 };
 
@@ -705,7 +705,7 @@
             }
         }
 
- operation_type blocked = operation_blocked;
+ operation_type blocked = operation_blocked;
         switch(side_rk_r)
         {
 
@@ -723,16 +723,16 @@
                 // two operations blocked, so the whole point does not need
                 // to be generated.
                 // So return false to indicate nothing is to be done.
- if (AssignPolicy::include_opposite)
- {
- tp.operations[Index].operation = operation_opposite;
- blocked = operation_opposite;
- }
- else
- {
- return false;
- }
- break;
+ if (AssignPolicy::include_opposite)
+ {
+ tp.operations[Index].operation = operation_opposite;
+ blocked = operation_opposite;
+ }
+ else
+ {
+ return false;
+ }
+ break;
         }
 
         // The other direction is always blocked when collinear opposite
@@ -785,24 +785,24 @@
             *out++ = tp;
         }
 
- if (AssignPolicy::include_opposite)
- {
- // Handle cases not yet handled above
- if ((dir_info.arrival[1] == -1 && dir_info.arrival[0] == 0)
- || (dir_info.arrival[0] == -1 && dir_info.arrival[1] == 0))
- {
- for (int i = 0; i < 2; i++)
- {
- tp.operations[i].operation = operation_opposite;
- }
- for (unsigned int i = 0; i < intersection_info.count; i++)
- {
- geometry::convert(intersection_info.intersections[i], tp.point);
- AssignPolicy::apply(tp, pi, qi, intersection_info, dir_info);
- *out++ = tp;
- }
- }
- }
+ if (AssignPolicy::include_opposite)
+ {
+ // Handle cases not yet handled above
+ if ((dir_info.arrival[1] == -1 && dir_info.arrival[0] == 0)
+ || (dir_info.arrival[0] == -1 && dir_info.arrival[1] == 0))
+ {
+ for (int i = 0; i < 2; i++)
+ {
+ tp.operations[i].operation = operation_opposite;
+ }
+ for (unsigned int i = 0; i < intersection_info.count; i++)
+ {
+ geometry::convert(intersection_info.intersections[i], tp.point);
+ AssignPolicy::apply(tp, pi, qi, intersection_info, dir_info);
+ *out++ = tp;
+ }
+ }
+ }
 
     }
 };
@@ -870,13 +870,13 @@
     static bool const include_opposite = false;
 
     template
- <
- typename Info,
- typename Point1,
- typename Point2,
- typename IntersectionInfo,
- typename DirInfo
- >
+ <
+ typename Info,
+ typename Point1,
+ typename Point2,
+ typename IntersectionInfo,
+ typename DirInfo
+ >
     static inline void apply(Info& , Point1 const& , Point2 const&, IntersectionInfo const&, DirInfo const&)
     {}
 
@@ -1028,15 +1028,15 @@
                     AssignPolicy::apply(tp, pi, qi, result.template get<0>(), result.template get<1>());
                     *out++ = tp;
                 }
- else
- {
+ else
+ {
                     equal_opposite
                         <
                             TurnInfo,
                             AssignPolicy
>::apply(pi, qi,
                             tp, out, result.template get<0>(), result.template get<1>());
- }
+ }
             }
             break;
             case 'c' :

Modified: trunk/boost/geometry/algorithms/disjoint.hpp
==============================================================================
--- trunk/boost/geometry/algorithms/disjoint.hpp (original)
+++ trunk/boost/geometry/algorithms/disjoint.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -87,13 +87,13 @@
 
     // We don't assign extra info:
     template
- <
- typename Info,
- typename Point1,
- typename Point2,
- typename IntersectionInfo,
- typename DirInfo
- >
+ <
+ typename Info,
+ typename Point1,
+ typename Point2,
+ typename IntersectionInfo,
+ typename DirInfo
+ >
     static inline void apply(Info& , Point1 const& , Point2 const&,
                 IntersectionInfo const&, DirInfo const&)
     {}

Modified: trunk/boost/geometry/algorithms/for_each.hpp
==============================================================================
--- trunk/boost/geometry/algorithms/for_each.hpp (original)
+++ trunk/boost/geometry/algorithms/for_each.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -67,17 +67,17 @@
     template <typename Range, typename Functor>
     static inline void apply(Range& range, Functor& f)
     {
- // The previous implementation called the std library:
+ // The previous implementation called the std library:
         // return (std::for_each(boost::begin(range), boost::end(range), f));
- // But that is not accepted for capturing lambda's.
- // It needs to do it like that to return the state of Functor f (f is passed by value in std::for_each).
+ // But that is not accepted for capturing lambda's.
+ // It needs to do it like that to return the state of Functor f (f is passed by value in std::for_each).
 
- // So we now loop manually.
+ // So we now loop manually.
 
- for (typename boost::range_iterator<Range>::type it = boost::begin(range); it != boost::end(range); ++it)
- {
- f(*it);
- }
+ for (typename boost::range_iterator<Range>::type it = boost::begin(range); it != boost::end(range); ++it)
+ {
+ f(*it);
+ }
     }
 };
 
@@ -261,7 +261,7 @@
     concept::check<Geometry>();
 
     dispatch::for_each_segment<Geometry>::apply(geometry, f);
- return f;
+ return f;
 }
 
 

Modified: trunk/boost/geometry/core/access.hpp
==============================================================================
--- trunk/boost/geometry/core/access.hpp (original)
+++ trunk/boost/geometry/core/access.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -137,8 +137,8 @@
     typename Geometry,
     typename
     CoordinateType,
- std::size_t Dimension,
- typename IsPointer
+ std::size_t Dimension,
+ typename IsPointer
>
 struct access
 {
@@ -153,7 +153,7 @@
     typename CoordinateType,
     std::size_t Index,
     std::size_t Dimension,
- typename IsPointer
+ typename IsPointer
>
 struct indexed_access
 {
@@ -279,7 +279,7 @@
             typename geometry::util::bare_type<Geometry>::type,
             typename coordinate_type<Geometry>::type,
             Dimension,
- typename boost::is_pointer<Geometry>::type
+ typename boost::is_pointer<Geometry>::type
> coord_access_type;
 
     return coord_access_type::get(geometry);
@@ -314,7 +314,7 @@
             typename geometry::util::bare_type<Geometry>::type,
             typename coordinate_type<Geometry>::type,
             Dimension,
- typename boost::is_pointer<Geometry>::type
+ typename boost::is_pointer<Geometry>::type
> coord_access_type;
 
     coord_access_type::set(geometry, value);
@@ -350,7 +350,7 @@
             typename coordinate_type<Geometry>::type,
             Index,
             Dimension,
- typename boost::is_pointer<Geometry>::type
+ typename boost::is_pointer<Geometry>::type
> coord_access_type;
 
     return coord_access_type::get(geometry);
@@ -387,7 +387,7 @@
             typename coordinate_type<Geometry>::type,
             Index,
             Dimension,
- typename boost::is_pointer<Geometry>::type
+ typename boost::is_pointer<Geometry>::type
> coord_access_type;
 
     coord_access_type::set(geometry, value);

Modified: trunk/boost/geometry/core/coordinate_dimension.hpp
==============================================================================
--- trunk/boost/geometry/core/coordinate_dimension.hpp (original)
+++ trunk/boost/geometry/core/coordinate_dimension.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -75,7 +75,7 @@
     : core_dispatch::dimension
         <
             typename tag<Geometry>::type,
- typename geometry::util::bare_type<Geometry>::type
+ typename geometry::util::bare_type<Geometry>::type
>
 {};
 

Modified: trunk/boost/geometry/core/coordinate_system.hpp
==============================================================================
--- trunk/boost/geometry/core/coordinate_system.hpp (original)
+++ trunk/boost/geometry/core/coordinate_system.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -66,9 +66,9 @@
     struct coordinate_system<point_tag, Point>
     {
         typedef typename traits::coordinate_system
- <
- typename geometry::util::bare_type<Point>::type
- >::type type;
+ <
+ typename geometry::util::bare_type<Point>::type
+ >::type type;
     };
 
 
@@ -89,7 +89,7 @@
     typedef typename core_dispatch::coordinate_system
         <
             typename tag<Geometry>::type,
- typename geometry::util::bare_type<Geometry>::type
+ typename geometry::util::bare_type<Geometry>::type
>::type type;
 };
 

Modified: trunk/boost/geometry/core/coordinate_type.hpp
==============================================================================
--- trunk/boost/geometry/core/coordinate_type.hpp (original)
+++ trunk/boost/geometry/core/coordinate_type.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -65,9 +65,9 @@
 struct coordinate_type<point_tag, Point>
 {
     typedef typename traits::coordinate_type
- <
+ <
             typename geometry::util::bare_type<Point>::type
- >::type type;
+ >::type type;
 };
 
 
@@ -85,11 +85,11 @@
 template <typename Geometry>
 struct coordinate_type
 {
- typedef typename core_dispatch::coordinate_type
- <
- typename tag<Geometry>::type,
- typename geometry::util::bare_type<Geometry>::type
- >::type type;
+ typedef typename core_dispatch::coordinate_type
+ <
+ typename tag<Geometry>::type,
+ typename geometry::util::bare_type<Geometry>::type
+ >::type type;
 };
 
 template <typename Geometry>

Modified: trunk/boost/geometry/core/tag.hpp
==============================================================================
--- trunk/boost/geometry/core/tag.hpp (original)
+++ trunk/boost/geometry/core/tag.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -62,7 +62,7 @@
 {
     typedef typename traits::tag
         <
- typename geometry::util::bare_type<Geometry>::type
+ typename geometry::util::bare_type<Geometry>::type
>::type type;
 };
 

Modified: trunk/boost/geometry/iterators/ever_circling_iterator.hpp
==============================================================================
--- trunk/boost/geometry/iterators/ever_circling_iterator.hpp (original)
+++ trunk/boost/geometry/iterators/ever_circling_iterator.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -196,7 +196,7 @@
         {
             m_index += m_size;
         }
- m_index = m_index % m_size;
+ m_index = m_index % m_size;
         this->m_iterator = boost::begin(*m_range) + m_index;
     }
 

Modified: trunk/boost/geometry/policies/relate/direction.hpp
==============================================================================
--- trunk/boost/geometry/policies/relate/direction.hpp (original)
+++ trunk/boost/geometry/policies/relate/direction.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -126,9 +126,9 @@
     typedef typename select_most_precise<coordinate_type, double>::type rtype;
 
 
- template <typename R>
+ template <typename R>
     static inline return_type segments_intersect(side_info const& sides,
- R const&,
+ R const&,
                     coordinate_type const& dx1, coordinate_type const& dy1,
                     coordinate_type const& dx2, coordinate_type const& dy2,
                     S1 const& s1, S2 const& s2)

Modified: trunk/boost/geometry/policies/relate/intersection_points.hpp
==============================================================================
--- trunk/boost/geometry/policies/relate/intersection_points.hpp (original)
+++ trunk/boost/geometry/policies/relate/intersection_points.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -42,9 +42,9 @@
             S1, S2, CalculationType
>::type coordinate_type;
 
- template <typename R>
+ template <typename R>
     static inline return_type segments_intersect(side_info const&,
- R const& r,
+ R const& r,
                     coordinate_type const& dx1, coordinate_type const& dy1,
                     coordinate_type const& , coordinate_type const& ,
                     S1 const& s1, S2 const& )

Modified: trunk/boost/geometry/policies/relate/tupled.hpp
==============================================================================
--- trunk/boost/geometry/policies/relate/tupled.hpp (original)
+++ trunk/boost/geometry/policies/relate/tupled.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -49,9 +49,9 @@
     // Get the same type, but at least a double
     typedef typename select_most_precise<coordinate_type, double>::type rtype;
 
- template <typename R>
+ template <typename R>
     static inline return_type segments_intersect(side_info const& sides,
- R const& r,
+ R const& r,
                     coordinate_type const& dx1, coordinate_type const& dy1,
                     coordinate_type const& dx2, coordinate_type const& dy2,
                     segment_type1 const& s1, segment_type2 const& s2)

Modified: trunk/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp
==============================================================================
--- trunk/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp (original)
+++ trunk/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -93,10 +93,10 @@
 {
 public :
 
- // See also ticket 5954 https://svn.boost.org/trac/boost/ticket/5954
- // Comparable is currently not possible here because it has to be compared to the squared of max_distance, and more.
- // For now we have to take the real distance.
- typedef PointDistanceStrategy distance_strategy_type;
+ // See also ticket 5954 https://svn.boost.org/trac/boost/ticket/5954
+ // Comparable is currently not possible here because it has to be compared to the squared of max_distance, and more.
+ // For now we have to take the real distance.
+ typedef PointDistanceStrategy distance_strategy_type;
     // typedef typename strategy::distance::services::comparable_type<PointDistanceStrategy>::type distance_strategy_type;
 
     typedef typename strategy::distance::services::return_type<distance_strategy_type>::type return_type;

Modified: trunk/boost/geometry/strategies/side_info.hpp
==============================================================================
--- trunk/boost/geometry/strategies/side_info.hpp (original)
+++ trunk/boost/geometry/strategies/side_info.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -150,7 +150,7 @@
             << sides[0].second << " "
             << sides[1].first << " "
             << sides[1].second
- << std::endl;
+ << std::endl;
     }
 
 

Modified: trunk/boost/geometry/strategies/strategy_transform.hpp
==============================================================================
--- trunk/boost/geometry/strategies/strategy_transform.hpp (original)
+++ trunk/boost/geometry/strategies/strategy_transform.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -253,22 +253,22 @@
         return false;
     }
 
- template <typename P, typename T>
- inline bool cartesian_to_spherical_equatorial3(T x, T y, T z, P& p)
- {
- assert_dimension<P, 3>();
-
- // http://en.wikipedia.org/wiki/List_of_canonical_coordinate_transformations#From_Cartesian_coordinates
- T const r = sqrt(x * x + y * y + z * z);
- set<2>(p, r);
- set_from_radian<0>(p, atan2(y, x));
- if (r > 0.0)
- {
- set_from_radian<1>(p, asin(z / r));
- return true;
- }
- return false;
- }
+ template <typename P, typename T>
+ inline bool cartesian_to_spherical_equatorial3(T x, T y, T z, P& p)
+ {
+ assert_dimension<P, 3>();
+
+ // http://en.wikipedia.org/wiki/List_of_canonical_coordinate_transformations#From_Cartesian_coordinates
+ T const r = sqrt(x * x + y * y + z * z);
+ set<2>(p, r);
+ set_from_radian<0>(p, atan2(y, x));
+ if (r > 0.0)
+ {
+ set_from_radian<1>(p, asin(z / r));
+ return true;
+ }
+ return false;
+ }
 
 } // namespace detail
 #endif // DOXYGEN_NO_DETAIL
@@ -383,11 +383,11 @@
 template <typename P1, typename P2>
 struct from_cartesian_3_to_spherical_equatorial_3
 {
- inline bool apply(P1 const& p1, P2& p2) const
- {
- assert_dimension<P1, 3>();
- return detail::cartesian_to_spherical_equatorial3(get<0>(p1), get<1>(p1), get<2>(p1), p2);
- }
+ inline bool apply(P1 const& p1, P2& p2) const
+ {
+ assert_dimension<P1, 3>();
+ return detail::cartesian_to_spherical_equatorial3(get<0>(p1), get<1>(p1), get<2>(p1), p2);
+ }
 };
 
 #ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
@@ -486,7 +486,7 @@
 template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
 struct default_strategy<cartesian_tag, spherical_equatorial_tag, CoordSys1, CoordSys2, 3, 3, P1, P2>
 {
- typedef from_cartesian_3_to_spherical_equatorial_3<P1, P2> type;
+ typedef from_cartesian_3_to_spherical_equatorial_3<P1, P2> type;
 };
 
 

Modified: trunk/boost/geometry/util/math.hpp
==============================================================================
--- trunk/boost/geometry/util/math.hpp (original)
+++ trunk/boost/geometry/util/math.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -44,17 +44,17 @@
 template <typename Type>
 struct equals<Type, true>
 {
- static inline Type get_max(Type const& a, Type const& b, Type const& c)
- {
- return (std::max)((std::max)(a, b), c);
- }
+ static inline Type get_max(Type const& a, Type const& b, Type const& c)
+ {
+ return (std::max)((std::max)(a, b), c);
+ }
 
     static inline bool apply(Type const& a, Type const& b)
     {
- if (a == b)
- {
- return true;
- }
+ if (a == b)
+ {
+ return true;
+ }
 
         // See http://www.parashift.com/c++-faq-lite/newbie.html#faq-29.17,
         // FUTURE: replace by some boost tool or boost::test::close_at_tolerance
@@ -76,11 +76,11 @@
 {
     static inline bool apply(Type const& a, Type const& b)
     {
- if (equals<Type, true>::apply(a, b))
- {
- return false;
- }
- return a < b;
+ if (equals<Type, true>::apply(a, b))
+ {
+ return false;
+ }
+ return a < b;
     }
 };
 

Modified: trunk/boost/geometry/util/rational.hpp
==============================================================================
--- trunk/boost/geometry/util/rational.hpp (original)
+++ trunk/boost/geometry/util/rational.hpp 2013-04-24 10:22:21 EDT (Wed, 24 Apr 2013)
@@ -39,13 +39,13 @@
         std::string before_part = source.substr(0, p);
         std::string const after_part = source.substr(p + 1);
 
- negate = false;
+ negate = false;
 
- if (before_part.size() > 0 && before_part[0] == '-')
- {
- negate = true;
- before_part.erase(0, 1);
- }
+ if (before_part.size() > 0 && before_part[0] == '-')
+ {
+ negate = true;
+ before_part.erase(0, 1);
+ }
         before = atol(before_part.c_str());
         after = atol(after_part.c_str());
         len = after_part.length();
@@ -71,9 +71,9 @@
             split_parts(source, p, before, after, negate, len);
 
             return negate
- ? -rational<T>(before, after)
- : rational<T>(before, after)
- ;
+ ? -rational<T>(before, after)
+ : rational<T>(before, after)
+ ;
 
         }
 
@@ -86,9 +86,9 @@
         }
 
         return negate
- ? -rational<T>(before) - rational<T>(after, den)
- : rational<T>(before) + rational<T>(after, den)
- ;
+ ? -rational<T>(before) - rational<T>(after, den)
+ : rational<T>(before) + rational<T>(after, den)
+ ;
     }
 };
 


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk