Doc corrections according to Monique's review + clean-up conflicts marks

Triangulation_3/doc/Triangulation_3/CGAL/Delaunay_triangulation_3.h

@@ -153,8 +153,9 @@ addition the empty sphere property of all the created faces.
 The optional argument `start` is used as a starting place for the search. 
 
 The optional argument `could_lock_zone` is used by the concurrency-safe
-version of the triangulation. When the pointer is not null, the insertion will
+version of the triangulation. If the pointer is not null, the insertion will
-try to lock cells before modifying them. If it succeeds, `*could_lock_zone`
+try to lock all the cells of the conflict zone, i.e.\ all the vertices that are
+inside or on the boundary of the conflict zone. If it succeeds, `*could_lock_zone`
 is true, otherwise it is false and the return value is Vertex_handle() 
 (the point is not inserted). In any case, the locked cells are not unlocked by the 
 function, leaving this choice to the user.
@@ -261,31 +262,26 @@ Removes the vertex `v` from the triangulation.
 */ 
 void remove(Vertex_handle v); 
 
-<<<<<<< HEAD
-/*!
-Removes the vertices specified by the iterator range `[first, beyond)`. 
-The function `remove(Vertex_handle)` is called over each element of the range. 
-The number of vertices removed is returned. 
-=======
 /*! 
 Removes the vertex `v` from the triangulation.
 
-This function is concurrency-safe if the triangulation is concurrency-safe. The removal will
+This function is concurrency-safe if the triangulation is concurrency-safe. 
-try to lock cells before deleting/modifying them. If it succeeds, `*could_lock_zone`
+It will first
+try to lock all the cells adjacent to `v`. If it succeeds, `*could_lock_zone`
 is true, otherwise it is false (and the point is not removed). In any case, 
 the locked cells are not unlocked by the function, leaving this choice to the user.
 
 This function will try to remove `v` only if the removal does not
-decrease the dimension. If the removal would decrease dimension, the function returns false
+decrease the dimension.
-(providing the zone could be locked, i.e.\ `*could_lock_zone` is `true`).
-
-\pre `v` is a finite vertex of the triangulation. 
-\pre `dt`.`dimension()` \f$ =3\f$.
 
 The return value is only meaningful if `*could_lock_zone` is `true`:
   - returns true if the vertex was removed
   - returns false if the vertex wasn't removed since it would decrease 
     the dimension.
+
+\pre `v` is a finite vertex of the triangulation. 
+\pre `dt`.`dimension()` \f$ =3\f$.
+
 */ 
 bool remove(Vertex_handle v, bool *could_lock_zone);
 
@@ -296,7 +292,6 @@ If parallelism is enabled, the points will be removed in parallel.
 Note that if at some step, the triangulation dimension becomes lower than 3,
 the removal of the remaining points will go on sequentially.
 
->>>>>>> Mesh_3-parallel-cjamin-old
 \pre (i) all vertices of the range are finite vertices of the triangulation; and (ii) no vertices are repeated in the range. 
 
 \tparam InputIterator must be an input iterator with value type `Vertex_handle`.
@@ -420,8 +415,10 @@ respectively in the output iterators:
 conflict, but `t->neighbor(i)` is not. 
 
 - `could_lock_zone`: The optional argument `could_lock_zone` is used by the concurrency-safe
-                     version of the triangulation. When the pointer is not null, the algorithm will
+                     version of the triangulation. If the pointer is not null, the algorithm will
-                     try to lock all the cells of the conflict zone. If it succeeds, `*could_lock_zone`
+                     try to lock all the cells of the conflict zone, i.e.\ all the vertices that are
+                     inside or on the boundary of the conflict zone (as a result, the boundary cells become
+                     partially locked). If it succeeds, `*could_lock_zone`
                      is true, otherwise it is false (and the returned conflict zone is only partial). In any case, 
                      the locked cells are not unlocked by the function, leaving this choice to the user.
 
@@ -455,8 +452,10 @@ conflict, but `t->neighbor(i)` is not.
 two cells (resp facets) in conflict. 
 
 - `could_lock_zone`: The optional argument `could_lock_zone` is used by the concurrency-safe
-                     version of the triangulation. When the pointer is not null, the algorithm will
+                     version of the triangulation. If the pointer is not null, the algorithm will
-                     try to lock all the cells of the conflict zone. If it succeeds, `*could_lock_zone`
+                     try to lock all the cells of the conflict zone, i.e.\ all the vertices that are
+                     inside or on the boundary of the conflict zone (as a result, the boundary cells become
+                     partially locked). If it succeeds, `*could_lock_zone`
                      is true, otherwise it is false (and the returned conflict zone is only partial). In any case, 
                      the locked cells are not unlocked by the function, leaving this choice to the user.
 

Triangulation_3/doc/Triangulation_3/CGAL/Regular_triangulation_3.h

@@ -137,8 +137,9 @@ then it is stored as a hidden point and this method returns the default
 constructed handle. 
 
 The optional argument `could_lock_zone` is used by the concurrency-safe
-version of the triangulation. When the pointer is not null, the insertion will
+version of the triangulation. If the pointer is not null, the insertion will
-try to lock cells before modifying them. If it succeeds, `*could_lock_zone`
+try to lock all the cells of the conflict zone, i.e.\ all the vertices that are
+inside or on the boundary of the conflict zone. If it succeeds, `*could_lock_zone`
 is true, otherwise it is false (and the point is not inserted). In any case, 
 the locked cells are not unlocked by the function, leaving this choice to the user.
 */ 
@@ -244,8 +245,9 @@ void remove(Vertex_handle v);
 /*!
 Removes the vertex `v` from the triangulation.
 
-This function is concurrency-safe if the triangulation is concurrency-safe. The removal will
+This function is concurrency-safe if the triangulation is concurrency-safe. 
-try to lock cells before deleting/modifying them. If it succeeds, `*could_lock_zone`
+It will first
+try to lock all the cells adjacent to `v`. If it succeeds, `*could_lock_zone`
 is true, otherwise it is false (and the point is not removed). In any case, 
 the locked cells are not unlocked by the function, leaving this choice to the user.
 
@@ -435,8 +437,10 @@ Compute the conflicts with `p`.
 @param bfit               The facets (resp. edges) on the boundary of the conflict zone, that is, the facets  (resp.\ edges) `(t, i)` where the cell (resp.. facet) `t` is in conflict, but `t->neighbor(i)` is not. 
 @param ifit               The facets (resp.\ edges) inside the conflict zone, that facets incident to two cells (resp.\ facets) in conflict. 
 @param could_lock_zone    The optional argument `could_lock_zone` is used by the concurrency-safe
-                          version of the triangulation. When the pointer is not null, the algorithm will
+                          version of the triangulation. If the pointer is not null, the algorithm will
-                          try to lock all the cells of the conflict zone. If it succeeds, `*could_lock_zone`
+                          try to lock all the cells of the conflict zone, i.e.\ all the vertices that are
+                          inside or on the boundary of the conflict zone (as a result, the boundary cells become
+                          partially locked). If it succeeds, `*could_lock_zone`
                           is true, otherwise it is false (and the returned conflict zone is only partial). In any case, 
                           the locked cells are not unlocked by the function, leaving this choice to the user.
 @param this_facet_must_be_in_the_cz 

Triangulation_3/doc/Triangulation_3/CGAL/Triangulation_3.h

@@ -1209,9 +1209,6 @@ template <class OutputIterator>
 OutputIterator 
 incident_cells(Vertex_handle v, OutputIterator cells) const; 
 
-<<<<<<< HEAD
-/*!
-=======
 /*! 
 Try to lock and copy the `Cell_handle`s of all cells incident to `v` into
 `cells`. 
@@ -1225,7 +1222,6 @@ bool
   try_lock_and_get_incident_cells(Vertex_handle v,
                                   std::vector<Cell_handle>& cells) const;
 /*!
->>>>>>> Mesh_3-parallel-cjamin-old
 Copies the `Cell_handle`s of all finite cells incident to `v` to the output 
 iterator `cells`. 
 Returns the resulting output iterator. 

Triangulation_3/doc/Triangulation_3/PackageDescription.txt

@@ -83,16 +83,10 @@ is opposite to the vertex with the same index. See
 
 ### Main Classes ###
 
-<<<<<<< HEAD
-- `CGAL::Triangulation_3<TriangulationTraits_3,TriangulationDataStructure_3>`
-- `CGAL::Delaunay_triangulation_3<DelaunayTriangulationTraits_3,TriangulationDataStructure_3,LocationPolicy>`
-- `CGAL::Regular_triangulation_3<RegularTriangulationTraits_3,TriangulationDataStructure_3>`
-=======
 - `CGAL::Triangulation_3<TriangulationTraits_3,TriangulationDataStructure_3,SpatialLockDataStructure_3>`
 - `CGAL::Delaunay_triangulation_3<DelaunayTriangulationTraits_3,TriangulationDataStructure_3,LocationPolicy,SpatialLockDataStructure_3>`
 - `CGAL::Triangulation_hierarchy_3<Tr>`
 - `CGAL::Regular_triangulation_3<RegularTriangulationTraits_3,TriangulationDataStructure_3,SpatialLockDataStructure_3>`
->>>>>>> Mesh_3-parallel-cjamin-old
 - `CGAL::Triangulation_cell_base_3<TriangulationTraits_3, TriangulationDSCellBase_3>`
 - `CGAL::Triangulation_cell_base_with_info_3<Info, TriangulationTraits_3, TriangulationCellBase_3>`
 - `CGAL::Triangulation_cell_base_with_circumcenter_3<DelaunayTriangulationTraits_3, TriangulationCellBase_3>`