From 8d7329f3e5ad843e553c3c5503cecc28ef2eead6 Mon Sep 17 00:00:00 2001
From: Gard Spreemann <gspreemann@gmail.com>
Date: Thu, 20 Apr 2017 11:10:45 +0200
Subject: GUDHI 2.0.0 as released by upstream in a tarball.

---
 .../Skeleton_blocker_complex_visitor.h             | 53 ++++++++++++----------
 .../Skeleton_blocker_link_superior.h               | 14 +++---
 .../Skeleton_blocker/Skeleton_blocker_off_io.h     | 11 +++--
 .../Skeleton_blocker_simple_geometric_traits.h     | 13 ++++--
 .../Skeleton_blocker_simple_traits.h               | 38 +++++++++-------
 .../Skeleton_blocker/Skeleton_blocker_simplex.h    | 12 ++---
 .../Skeleton_blocker_sub_complex.h                 | 49 ++++++--------------
 .../gudhi/Skeleton_blocker/internal/Top_faces.h    |  5 +-
 include/gudhi/Skeleton_blocker/internal/Trie.h     |  9 ++--
 .../Skeleton_blockers_blockers_iterators.h         |  3 +-
 .../iterators/Skeleton_blockers_edges_iterators.h  |  3 +-
 .../iterators/Skeleton_blockers_iterators.h        |  2 +-
 .../Skeleton_blockers_simplices_iterators.h        | 38 ++++++++--------
 .../Skeleton_blockers_triangles_iterators.h        | 14 ++++--
 .../Skeleton_blockers_vertices_iterators.h         | 12 ++---
 15 files changed, 137 insertions(+), 139 deletions(-)

(limited to 'include/gudhi/Skeleton_blocker')

diff --git a/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h b/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
index 32f40a4b..ba3636bc 100644
--- a/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
+++ b/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
 
@@ -27,7 +28,7 @@
 namespace Gudhi {
 
 namespace skeleton_blocker {
-// todo rajouter les const
+// TODO(DS): to be constified
 
 /**
  *@class Skeleton_blocker_complex_visitor
@@ -36,7 +37,7 @@ namespace skeleton_blocker {
 template<typename Vertex_handle>
 class Skeleton_blocker_complex_visitor {
  public:
-  virtual ~Skeleton_blocker_complex_visitor() {}
+  virtual ~Skeleton_blocker_complex_visitor() { }
 
   virtual void on_add_vertex(Vertex_handle) = 0;
   virtual void on_remove_vertex(Vertex_handle) = 0;
@@ -61,9 +62,9 @@ class Skeleton_blocker_complex_visitor {
   virtual void on_swaped_edge(Vertex_handle a, Vertex_handle b,
                               Vertex_handle x) = 0;
   virtual void on_add_blocker(
-      const Skeleton_blocker_simplex<Vertex_handle>&) = 0;
+                              const Skeleton_blocker_simplex<Vertex_handle>&) = 0;
   virtual void on_delete_blocker(
-      const Skeleton_blocker_simplex<Vertex_handle>*) = 0;
+                                 const Skeleton_blocker_simplex<Vertex_handle>*) = 0;
 };
 
 /**
@@ -73,24 +74,23 @@ class Skeleton_blocker_complex_visitor {
  */
 template<typename Vertex_handle>
 class Dummy_complex_visitor : public Skeleton_blocker_complex_visitor<
-    Vertex_handle> {
+Vertex_handle> {
  public:
-  void on_add_vertex(Vertex_handle) {
-  }
-  void on_remove_vertex(Vertex_handle) {
-  }
-  void on_add_edge_without_blockers(Vertex_handle a, Vertex_handle b) {
-  }
-  void on_remove_edge(Vertex_handle a, Vertex_handle b) {
-  }
-  void on_changed_edge(Vertex_handle a, Vertex_handle b) {
-  }
-  void on_swaped_edge(Vertex_handle a, Vertex_handle b, Vertex_handle x) {
-  }
-  void on_add_blocker(const Skeleton_blocker_simplex<Vertex_handle>&) {
-  }
-  void on_delete_blocker(const Skeleton_blocker_simplex<Vertex_handle>*) {
-  }
+  void on_add_vertex(Vertex_handle) { }
+
+  void on_remove_vertex(Vertex_handle) { }
+
+  void on_add_edge_without_blockers(Vertex_handle a, Vertex_handle b) { }
+
+  void on_remove_edge(Vertex_handle a, Vertex_handle b) { }
+
+  void on_changed_edge(Vertex_handle a, Vertex_handle b) { }
+
+  void on_swaped_edge(Vertex_handle a, Vertex_handle b, Vertex_handle x) { }
+
+  void on_add_blocker(const Skeleton_blocker_simplex<Vertex_handle>&) { }
+
+  void on_delete_blocker(const Skeleton_blocker_simplex<Vertex_handle>*) { }
 };
 
 /**
@@ -100,29 +100,36 @@ class Dummy_complex_visitor : public Skeleton_blocker_complex_visitor<
  */
 template<typename Vertex_handle>
 class Print_complex_visitor : public Skeleton_blocker_complex_visitor<
-    Vertex_handle> {
+Vertex_handle> {
  public:
   void on_add_vertex(Vertex_handle v) {
     std::cerr << "on_add_vertex:" << v << std::endl;
   }
+
   void on_remove_vertex(Vertex_handle v) {
     std::cerr << "on_remove_vertex:" << v << std::endl;
   }
+
   void on_add_edge_without_blockers(Vertex_handle a, Vertex_handle b) {
     std::cerr << "on_add_edge_without_blockers:" << a << "," << b << std::endl;
   }
+
   void on_remove_edge(Vertex_handle a, Vertex_handle b) {
     std::cerr << "on_remove_edge:" << a << "," << b << std::endl;
   }
+
   void on_changed_edge(Vertex_handle a, Vertex_handle b) {
     std::cerr << "on_changed_edge:" << a << "," << b << std::endl;
   }
+
   void on_swaped_edge(Vertex_handle a, Vertex_handle b, Vertex_handle x) {
     std::cerr << "on_swaped_edge:" << a << "," << b << "," << x << std::endl;
   }
+
   void on_add_blocker(const Skeleton_blocker_simplex<Vertex_handle>& b) {
     std::cerr << "on_add_blocker:" << b << std::endl;
   }
+
   void on_delete_blocker(const Skeleton_blocker_simplex<Vertex_handle>* b) {
     std::cerr << "on_delete_blocker:" << b << std::endl;
   }
diff --git a/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h b/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
index 3bfb5d11..d4b60613 100644
--- a/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
+++ b/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
 
@@ -36,7 +37,7 @@ template<class ComplexType> class Skeleton_blocker_sub_complex;
  */
 template<typename ComplexType>
 class Skeleton_blocker_link_superior : public Skeleton_blocker_link_complex<
-    ComplexType> {
+ComplexType> {
   typedef typename ComplexType::Edge_handle Edge_handle;
 
   typedef typename ComplexType::boost_vertex_handle boost_vertex_handle;
@@ -54,20 +55,17 @@ class Skeleton_blocker_link_superior : public Skeleton_blocker_link_complex<
   typedef typename ComplexType::Root_simplex_handle::Simplex_vertex_const_iterator IdSimplexConstIterator;
 
   Skeleton_blocker_link_superior()
-      : Skeleton_blocker_link_complex<ComplexType>(true) {
-  }
+      : Skeleton_blocker_link_complex<ComplexType>(true) { }
 
   Skeleton_blocker_link_superior(const ComplexType & parent_complex,
                                  Simplex& alpha_parent_adress)
       : Skeleton_blocker_link_complex<ComplexType>(parent_complex,
-                                                   alpha_parent_adress, true) {
-  }
+                                                   alpha_parent_adress, true) { }
 
   Skeleton_blocker_link_superior(const ComplexType & parent_complex,
                                  Vertex_handle a_parent_adress)
       : Skeleton_blocker_link_complex<ComplexType>(parent_complex,
-                                                   a_parent_adress, true) {
-  }
+                                                   a_parent_adress, true) { }
 };
 
 }  // namespace skeleton_blocker
diff --git a/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h b/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
index ba46c49e..747e60f1 100644
--- a/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
+++ b/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
 
@@ -49,8 +50,8 @@ class Skeleton_blocker_off_flag_visitor_reader {
       load_only_points_(load_only_points) { }
 
   void init(int dim, int num_vertices, int num_faces, int num_edges) {
-    // todo do an assert to check that this number are correctly read
-    // todo reserve size for vector points
+    // TODO(DS): do an assert to check that this number are correctly read
+    // TODO(DS): reserve size for vector points
   }
 
   void point(const std::vector<double>& point) {
@@ -108,7 +109,7 @@ class Skeleton_blocker_off_visitor_reader {
 
   void done() {
     complex_ = make_complex_from_top_faces<Complex>(maximal_faces_.begin(), maximal_faces_.end(),
-                                           points_.begin(), points_.end() );
+                                                    points_.begin(), points_.end());
   }
 };
 
@@ -140,7 +141,7 @@ class Skeleton_blocker_off_reader {
   }
 
   /**
-   * return true iff reading did not meet problems.
+   * return true if reading did not meet problems.
    */
   bool is_valid() const {
     return valid_;
diff --git a/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h b/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
index fb4a1106..275376e6 100644
--- a/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
+++ b/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
 
@@ -39,7 +40,7 @@ namespace skeleton_blocker {
  */
 template<typename GeometryTrait>
 struct Skeleton_blocker_simple_geometric_traits :
-    public Skeleton_blocker_simple_traits {
+public Skeleton_blocker_simple_traits {
  public:
   typedef GeometryTrait GT;
   typedef typename GT::Point Point;
@@ -57,19 +58,20 @@ struct Skeleton_blocker_simple_geometric_traits :
     Point& point() {
       return point_;
     }
+
     const Point& point() const {
       return point_;
     }
   };
 
   class Simple_geometric_edge :
-      public Skeleton_blocker_simple_traits::Graph_edge {
+  public Skeleton_blocker_simple_traits::Graph_edge {
     int index_;
    public:
     Simple_geometric_edge()
         : Skeleton_blocker_simple_traits::Graph_edge(),
-          index_(-1) {
-    }
+        index_(-1) { }
+
     /**
      * @brief Allows to modify the index of the edge.
      * The indices of the edge are used to store heap information
@@ -78,6 +80,7 @@ struct Skeleton_blocker_simple_geometric_traits :
     int& index() {
       return index_;
     }
+
     int index() const {
       return index_;
     }
diff --git a/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h b/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
index 31bec3b6..3835cf77 100644
--- a/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
+++ b/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
 #define SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
 
@@ -48,9 +49,9 @@ struct Skeleton_blocker_simple_traits {
    */
   struct Root_vertex_handle {
     typedef int boost_vertex_handle;
+
     explicit Root_vertex_handle(boost_vertex_handle val = -1)
-        : vertex(val) {
-    }
+        : vertex(val) { }
     boost_vertex_handle vertex;
 
     bool operator!=(const Root_vertex_handle& other) const {
@@ -65,8 +66,8 @@ struct Skeleton_blocker_simple_traits {
       return this->vertex < other.vertex;
     }
 
-    friend std::ostream& operator <<(std::ostream& o,
-                                     const Root_vertex_handle & v) {
+    friend std::ostream& operator<<(std::ostream& o,
+                                    const Root_vertex_handle & v) {
       o << v.vertex;
       return o;
     }
@@ -74,11 +75,13 @@ struct Skeleton_blocker_simple_traits {
 
   struct Vertex_handle {
     typedef int boost_vertex_handle;
+
     explicit Vertex_handle(boost_vertex_handle val = -1)
-        : vertex(val) {
-    }
+        : vertex(val) { }
 
-    operator int() const { return static_cast<int>(vertex); }
+    operator int() const {
+      return static_cast<int> (vertex);
+    }
 
     boost_vertex_handle vertex;
 
@@ -94,7 +97,7 @@ struct Skeleton_blocker_simple_traits {
       return this->vertex < other.vertex;
     }
 
-    friend std::ostream& operator <<(std::ostream& o, const Vertex_handle & v) {
+    friend std::ostream& operator<<(std::ostream& o, const Vertex_handle & v) {
       o << v.vertex;
       return o;
     }
@@ -105,21 +108,24 @@ struct Skeleton_blocker_simple_traits {
     Root_vertex_handle id_;
 
    public:
-    virtual ~Graph_vertex() {
-    }
+    virtual ~Graph_vertex() { }
 
     void activate() {
       is_active_ = true;
     }
+
     void deactivate() {
       is_active_ = false;
     }
+
     bool is_active() const {
       return is_active_;
     }
+
     void set_id(Root_vertex_handle i) {
       id_ = i;
     }
+
     Root_vertex_handle get_id() const {
       return id_;
     }
@@ -130,7 +136,7 @@ struct Skeleton_blocker_simple_traits {
       return res.str();
     }
 
-    friend std::ostream& operator <<(std::ostream& o, const Graph_vertex & v) {
+    friend std::ostream& operator<<(std::ostream& o, const Graph_vertex & v) {
       o << v.to_string();
       return o;
     }
@@ -144,13 +150,13 @@ struct Skeleton_blocker_simple_traits {
    public:
     Graph_edge()
         : a_(-1),
-          b_(-1),
-          index_(-1) {
-    }
+        b_(-1),
+        index_(-1) { }
 
     int& index() {
       return index_;
     }
+
     int index() const {
       return index_;
     }
@@ -168,7 +174,7 @@ struct Skeleton_blocker_simple_traits {
       return b_;
     }
 
-    friend std::ostream& operator <<(std::ostream& o, const Graph_edge & v) {
+    friend std::ostream& operator<<(std::ostream& o, const Graph_edge & v) {
       o << "(" << v.a_ << "," << v.b_ << " - id = " << v.index();
       return o;
     }
diff --git a/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h b/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
index 3c7f1dd5..aa6f2215 100644
--- a/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
+++ b/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -63,7 +63,6 @@ class Skeleton_blocker_simplex {
    */
   //@{
 
-  // Skeleton_blocker_simplex():simplex_set() {}
   void clear() {
     simplex_set.clear();
   }
@@ -89,8 +88,7 @@ class Skeleton_blocker_simplex {
     add_vertex(v);
   }
 
-  void add_vertices() {
-  }
+  void add_vertices() { }
 
   /**
    * Initialize a simplex with a string such as {0,1,2}
@@ -192,7 +190,6 @@ class Skeleton_blocker_simplex {
     return simplex_set.crend();
   }
 
-
   typename std::set<T>::iterator begin() {
     return simplex_set.begin();
   }
@@ -236,6 +233,7 @@ class Skeleton_blocker_simplex {
     assert(!empty());
     return *(simplex_set.rbegin());
   }
+
   /**
    * @return true iff the simplex contains the simplex a.
    */
@@ -351,8 +349,8 @@ class Skeleton_blocker_simplex {
 
   //@}
 
-  friend std::ostream& operator <<(std::ostream& o,
-                                   const Skeleton_blocker_simplex & sigma) {
+  friend std::ostream& operator<<(std::ostream& o,
+                                  const Skeleton_blocker_simplex & sigma) {
     bool first = true;
     o << "{";
     for (auto i : sigma) {
diff --git a/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h b/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
index 196fe8c0..fadf6619 100644
--- a/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
+++ b/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -159,7 +159,7 @@ class Skeleton_blocker_sub_complex : public ComplexType {
       if (simplex.contains(*blocker)) {
         Root_simplex_handle blocker_root(parent_complex.get_id(*(blocker)));
         Simplex blocker_restr(
-            *(this->get_simplex_address(blocker_root)));
+                              *(this->get_simplex_address(blocker_root)));
         this->add_blocker(new Simplex(blocker_restr));
       }
     }
@@ -190,14 +190,15 @@ class Skeleton_blocker_sub_complex : public ComplexType {
   //  */
   // boost::optional<Simplex> get_address(const Root_simplex_handle & s) const;
 
-// private:
+  // private:
   /**
    *  same as get_address except that it will return a simplex in any case.
    *  The vertices that were not found are not added.
    */
   // @remark should be private but problem with VS
+
   std::vector<boost::optional<Vertex_handle> > get_addresses(
-      const Root_simplex_handle & s) const {
+                                                             const Root_simplex_handle & s) const {
     std::vector < boost::optional<Vertex_handle> > res;
     for (auto i : s) {
       res.push_back(get_address(i));
@@ -214,14 +215,14 @@ class Skeleton_blocker_sub_complex : public ComplexType {
  */
 template<typename ComplexType>
 bool proper_face_in_union(
-    Skeleton_blocker_sub_complex<ComplexType> & link,
-    std::vector<boost::optional<typename ComplexType::Vertex_handle> > & addresses_sigma_in_link,
-    int vertex_to_be_ignored) {
+                          Skeleton_blocker_sub_complex<ComplexType> & link,
+                          std::vector<boost::optional<typename ComplexType::Vertex_handle> > & addresses_sigma_in_link,
+                          std::size_t vertex_to_be_ignored) {
   // we test that all vertices of 'addresses_sigma_in_link' but 'vertex_to_be_ignored'
   // are in link1 if it is the case we construct the corresponding simplex
   bool vertices_sigma_are_in_link = true;
   typename ComplexType::Simplex sigma_in_link;
-  for (int i = 0; i < addresses_sigma_in_link.size(); ++i) {
+  for (std::size_t i = 0; i < addresses_sigma_in_link.size(); ++i) {
     if (i != vertex_to_be_ignored) {
       if (!addresses_sigma_in_link[i]) {
         vertices_sigma_are_in_link = false;
@@ -236,43 +237,24 @@ bool proper_face_in_union(
   return vertices_sigma_are_in_link && link.contains(sigma_in_link);
 }
 
-/*
- template<typename ComplexType>
- bool
- proper_faces_in_union(Skeleton_blocker_simplex<typename ComplexType::Root_vertex_handle> & sigma, Skeleton_blocker_sub_complex<ComplexType> & link1, Skeleton_blocker_sub_complex<ComplexType> & link2)
- {
- typedef typename ComplexType::Vertex_handle  Vertex_handle;
- std::vector<boost::optional<Vertex_handle> > addresses_sigma_in_link1 = link1.get_addresses(sigma);
- std::vector<boost::optional<Vertex_handle> > addresses_sigma_in_link2 = link2.get_addresses(sigma);
-
- for (int current_index = 0; current_index < addresses_sigma_in_link1.size(); ++current_index)
- {
-
- if (!proper_face_in_union(link1, addresses_sigma_in_link1, current_index)
- && !proper_face_in_union(link2, addresses_sigma_in_link2, current_index)){
- return false;
- }
- }
- return true;
- }*/
-
 // Remark: this function should be friend in order to leave get_adresses private
 // however doing so seemes currently not possible due to a visual studio bug c2668
 // "the compiler does not support partial ordering of template functions as specified in the C++ Standard"
 // http://www.serkey.com/error-c2668-ambiguous-call-to-overloaded-function-bb45ft.html
+
 template<typename ComplexType>
 bool proper_faces_in_union(
-    Skeleton_blocker_simplex<typename ComplexType::Root_vertex_handle> & sigma,
-    Skeleton_blocker_sub_complex<ComplexType> & link1,
-    Skeleton_blocker_sub_complex<ComplexType> & link2) {
+                           Skeleton_blocker_simplex<typename ComplexType::Root_vertex_handle> & sigma,
+                           Skeleton_blocker_sub_complex<ComplexType> & link1,
+                           Skeleton_blocker_sub_complex<ComplexType> & link2) {
   typedef typename ComplexType::Vertex_handle Vertex_handle;
   std::vector < boost::optional<Vertex_handle> > addresses_sigma_in_link1 =
       link1.get_addresses(sigma);
   std::vector < boost::optional<Vertex_handle> > addresses_sigma_in_link2 =
       link2.get_addresses(sigma);
 
-  for (int current_index = 0; current_index < addresses_sigma_in_link1.size();
-      ++current_index) {
+  for (std::size_t current_index = 0; current_index < addresses_sigma_in_link1.size();
+       ++current_index) {
     if (!proper_face_in_union(link1, addresses_sigma_in_link1, current_index)
         && !proper_face_in_union(link2, addresses_sigma_in_link2,
                                  current_index)) {
@@ -289,4 +271,3 @@ namespace skbl = skeleton_blocker;
 }  // namespace Gudhi
 
 #endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
-
diff --git a/include/gudhi/Skeleton_blocker/internal/Top_faces.h b/include/gudhi/Skeleton_blocker/internal/Top_faces.h
index 39d95661..2b681752 100644
--- a/include/gudhi/Skeleton_blocker/internal/Top_faces.h
+++ b/include/gudhi/Skeleton_blocker/internal/Top_faces.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
 #define SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
 
@@ -69,4 +70,4 @@ namespace skbl = skeleton_blocker;
 
 }  // namespace Gudhi
 
-#endif  // SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
+#endif   // SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
diff --git a/include/gudhi/Skeleton_blocker/internal/Trie.h b/include/gudhi/Skeleton_blocker/internal/Trie.h
index cdc47b8a..2c9602fa 100644
--- a/include/gudhi/Skeleton_blocker/internal/Trie.h
+++ b/include/gudhi/Skeleton_blocker/internal/Trie.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -21,7 +21,6 @@
  * 
  */
 
-
 #ifndef SKELETON_BLOCKER_INTERNAL_TRIE_H_
 #define SKELETON_BLOCKER_INTERNAL_TRIE_H_
 
@@ -148,7 +147,7 @@ struct Trie {
   }
 
   void remove_leaf() {
-    assert(is_leaf);
+    assert(is_leaf());
     if (!is_root())
       parent_->childs.erase(this);
   }
@@ -240,7 +239,7 @@ struct Tries {
 
   std::vector<Simplex> next_dimension_simplices() const {
     std::vector<Simplex> res;
-    while (!to_see_.empty() && to_see_.front()->simplex().dimension() == current_dimension_) {
+    while (!(to_see_.empty()) && (to_see_.front()->simplex().dimension() == current_dimension_)) {
       res.emplace_back(to_see_.front()->simplex());
       for (auto child : to_see_.front()->childs)
         to_see_.push_back(child.get());
@@ -257,7 +256,7 @@ struct Tries {
 
  private:
   mutable std::deque<STrie*> to_see_;
-  mutable unsigned current_dimension_ = 0;
+  mutable int current_dimension_ = 0;
   std::vector<STrie*> cofaces_;
 };
 
diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
index 4dbc9ed3..d2fff960 100644
--- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
+++ b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
 
diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
index 15618932..b90dcf34 100644
--- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
+++ b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_
 
diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
index cc3ed276..1351614f 100644
--- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
+++ b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
@@ -4,7 +4,7 @@
   *
   *    Author(s):       David Salinas
   *
-  *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+  *    Copyright (C) 2014  INRIA
   *
   *    This program is free software: you can redistribute it and/or modify
   *    it under the terms of the GNU General Public License as published by
diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
index 3b941be5..2acdb555 100644
--- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
+++ b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
 
@@ -68,10 +69,11 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
   Vertex_handle v;
   std::shared_ptr<Link> link_v;
   std::shared_ptr<Trie> trie;
-  std::list<Trie*> nodes_to_be_seen;  // todo deque
+  // TODO(DS): use a deque instead
+  std::list<Trie*> nodes_to_be_seen;
 
  public:
-  Simplex_around_vertex_iterator() : complex(0) {}
+  Simplex_around_vertex_iterator() : complex(0) { }
 
   Simplex_around_vertex_iterator(const Complex* complex_, Vertex_handle v_) :
       complex(complex_),
@@ -81,15 +83,16 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
     compute_trie_and_nodes_to_be_seen();
   }
 
-  // todo avoid useless copy
-  // todo currently just work if copy begin iterator
+  // TODO(DS): avoid useless copy
+  // TODO(DS): currently just work if copy begin iterator
   Simplex_around_vertex_iterator(const Simplex_around_vertex_iterator& other) :
       complex(other.complex),
       v(other.v),
       link_v(other.link_v),
       trie(other.trie),
       nodes_to_be_seen(other.nodes_to_be_seen) {
-    if (!other.is_end()) {}
+    if (!other.is_end()) {
+    }
   }
 
   /**
@@ -159,7 +162,8 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
 
     bool both_non_empty = !nodes_to_be_seen.empty() && !other.nodes_to_be_seen.empty();
 
-    if (!both_non_empty) return false;  // one is empty the other is not
+    // one is empty the other is not
+    if (!both_non_empty) return false;
 
     bool same_node = (**(nodes_to_be_seen.begin()) == **(other.nodes_to_be_seen.begin()));
     return same_node;
@@ -238,7 +242,6 @@ public boost::iterator_facade < Simplex_iterator<SkeletonBlockerComplex>
   }
 
  private:
-  // todo return to private
   Simplex_iterator(const Complex* complex, bool end) :
       complex_(complex) {
     set_end();
@@ -306,7 +309,7 @@ public boost::iterator_facade < Simplex_iterator<SkeletonBlockerComplex>
 
 /**
  * Iterator through the maximal faces of the coboundary of a simplex.
- */ 
+ */
 template<typename SkeletonBlockerComplex, typename Link>
 class Simplex_coboundary_iterator :
 public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerComplex, Link>
@@ -329,12 +332,12 @@ public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerCompl
   Complex_vertex_iterator link_vertex_end;
 
  public:
-  Simplex_coboundary_iterator() : complex(0) {}
+  Simplex_coboundary_iterator() : complex(0) { }
 
   Simplex_coboundary_iterator(const Complex* complex_, const Simplex& sigma_) :
       complex(complex_),
       sigma(sigma_),
-      //need only vertices of the link hence the true flag
+      // need only vertices of the link hence the true flag
       link(new Link(*complex_, sigma_, false, true)) {
     auto link_vertex_range = link->vertex_range();
     current_vertex = link_vertex_range.begin();
@@ -347,9 +350,9 @@ public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerCompl
       link(other.link),
       current_vertex(other.current_vertex),
       link_vertex_end(other.link_vertex_end) { }
-  
+
   // returns an iterator to the end
-  Simplex_coboundary_iterator(const Complex* complex_,const Simplex& sigma_, bool end) :
+  Simplex_coboundary_iterator(const Complex* complex_, const Simplex& sigma_, bool end) :
       complex(complex_),
       sigma(sigma_) {
     // to represent an end iterator without having to build a useless link, we use
@@ -361,7 +364,7 @@ public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerCompl
     return complex->convert_handle_from_another_complex(*link, link_vh);
   }
 
-public:
+ public:
   friend std::ostream& operator<<(std::ostream& stream, const Simplex_coboundary_iterator& sci) {
     return stream;
   }
@@ -369,8 +372,8 @@ public:
   // assume that iterator points to the same complex and comes from the same simplex
   bool equal(const Simplex_coboundary_iterator& other) const {
     assert(complex == other.complex && sigma == other.sigma);
-    if(is_end()) return other.is_end();
-    if(other.is_end()) return is_end();
+    if (is_end()) return other.is_end();
+    if (other.is_end()) return is_end();
     return *current_vertex == *(other.current_vertex);
   }
 
@@ -384,13 +387,12 @@ public:
     return res;
   }
 
-private:
+ private:
   bool is_end() const {
     return !link || current_vertex == link_vertex_end;
   }
 };
 
-
 }  // namespace skeleton_blocker
 
 namespace skbl = skeleton_blocker;
diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
index b2dd9a21..736941dd 100644
--- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
+++ b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
 
@@ -135,7 +136,7 @@ typename SkeletonBlockerComplex::Simplex const
   Triangle_iterator(const SkeletonBlockerComplex* complex) :
       complex_(complex),
       current_vertex_(complex->vertex_range().begin()),
-      current_triangle_(complex, *current_vertex_),  // xxx this line is problematic is the complex is empty
+      current_triangle_(complex, *current_vertex_),  // this line is problematic is the complex is empty
       is_end_(false) {
     assert(!complex->empty());
     gotoFirstTriangle();
@@ -172,7 +173,8 @@ typename SkeletonBlockerComplex::Simplex const
     bool both_arent_finished = !is_finished() && !other.is_finished();
     // if the two iterators are not finished, they must have the same state
     return (complex_ == other.complex_) && (both_are_finished || ((both_arent_finished) &&
-        current_vertex_ == other.current_vertex_ && current_triangle_ == other.current_triangle_));
+                                                                  current_vertex_ == other.current_vertex_ &&
+                                                                  current_triangle_ == other.current_triangle_));
   }
 
   Simplex dereference() const {
@@ -183,8 +185,10 @@ typename SkeletonBlockerComplex::Simplex const
   // goto the next vertex that has a triangle pending or the
   // end vertex iterator if none exists
   void goto_next_vertex() {
-    assert(current_triangle_.finished());  // we mush have consume all triangles passing through the vertex
-    assert(!is_finished());  // we must not be done
+    // we must have consume all triangles passing through the vertex
+    assert(current_triangle_.finished());
+    // we must not be done
+    assert(!is_finished());
 
     ++current_vertex_;
 
diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
index f06cab71..9e9ae961 100644
--- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
+++ b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
@@ -4,7 +4,7 @@
  *
  *    Author(s):       David Salinas
  *
- *    Copyright (C) 2014  INRIA Sophia Antipolis-Mediterranee (France)
+ *    Copyright (C) 2014  INRIA
  *
  *    This program is free software: you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -19,6 +19,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
 #define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
 
@@ -103,7 +104,7 @@ class Vertex_iterator : public boost::iterator_facade< Vertex_iterator <Skeleton
 };
 
 template<typename SkeletonBlockerComplex>
-class Neighbors_vertices_iterator: public boost::iterator_facade < Neighbors_vertices_iterator<SkeletonBlockerComplex>
+class Neighbors_vertices_iterator : public boost::iterator_facade < Neighbors_vertices_iterator<SkeletonBlockerComplex>
 , typename SkeletonBlockerComplex::Vertex_handle const
 , boost::forward_traversal_tag
 , typename SkeletonBlockerComplex::Vertex_handle const> {
@@ -122,9 +123,6 @@ class Neighbors_vertices_iterator: public boost::iterator_facade < Neighbors_ver
   boost_adjacency_iterator end_;
 
  public:
-  // boost_adjacency_iterator ai, ai_end;
-  // for (tie(ai, ai_end) = adjacent_vertices(v.vertex, skeleton); ai != ai_end; ++ai) {
-
   Neighbors_vertices_iterator() : complex(NULL) { }
 
   Neighbors_vertices_iterator(const Complex* complex_, Vertex_handle v_) :
@@ -157,7 +155,7 @@ class Neighbors_vertices_iterator: public boost::iterator_facade < Neighbors_ver
   }
 
  private:
-  // todo remove this ugly hack
+  // TODO(DS): remove this ugly hack
   void set_end() {
     current_ = end_;
   }
@@ -170,5 +168,3 @@ namespace skbl = skeleton_blocker;
 }  // namespace Gudhi
 
 #endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
-
-
-- 
cgit v1.2.3