Summary of Changes

This PR introduces many factorizations and cleaning in the PSP package (internal code only, no API change):

• In lots of places, points were copied in a first container then passed to the KD tree (which copied them again), which seems quite inefficient. The KD tree now works on the input range (using iterators to limit copies if the data set is big)
• The neighbor search that I already factorized some time ago is even more factorized now (even the tree type/instantiation is now handled in a single class, removing many code duplication)
• TBB functors are removed and replaced by lambdas (which are much more self-contained as no typedefs/templates are required)
• The Parallel_callback I introduced to handle callbacks in parallel mode is replaced by a Callback_wrapper which indifferently works with sequential and parallel
• A function (so far undocumented) CGAL::for_each is introduced to run a functor on a range either sequentially or in parallel with TBB. It checks that no parallel tag is used without TBB being linked and it handles the cases of parallel loop on non-random access iterators (by copying iterators in a vector, which is equivalent to what was done in PSP in general, only now it only happens in the worst case scenario)

In general, the code of PSP is largely reduced and much more readable. Many functions were written ike that:

#ifndef CGAL_LINKED_WITH_TBB
  CGAL_static_assertion_msg (!(boost::is_convertible<ConcurrencyTag, Parallel_tag>::value),
			     "Parallel_tag is enabled but TBB is unavailable.");
#else
   if (boost::is_convertible<ConcurrencyTag,Parallel_tag>::value)
   {
     CGAL::internal::Tbb_functor_defined_somewhere_else</* many template paremeters */>
       f (/* many parameters */);
     tbb::parallel_for(tbb::blocked_range<size_t>(0, kd_tree_points.size ()), f);
   }
   else
#endif
     {
       for(typename PointRange::const_iterator it = points.begin(); it != points.end(); it++, nb++)
       {
         /* The actual algorithm, often duplicated in TBB functor */
       }
     }

Now they look like that:

  CGAL::for_each<ConcurrencyTag>
    (points,
     [&](const typename PointRange::const_iterator::value_type& t)
     {
       /* The actual algorithm */
     });

Release Management

• Affected package(s): PSP, Demo