Added thirdparty: boost library

thirdparty/include/boost/graph/planar_detail/face_iterators.hpp

@@ -0,0 +1,332 @@
+//=======================================================================
+// Copyright (c) Aaron Windsor 2007
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#ifndef __FACE_ITERATORS_HPP__
+#define __FACE_ITERATORS_HPP__
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/graph/graph_traits.hpp>
+
+namespace boost
+{
+
+// tags for defining traversal properties
+
+// VisitorType
+struct lead_visitor
+{
+};
+struct follow_visitor
+{
+};
+
+// TraversalType
+struct single_side
+{
+};
+struct both_sides
+{
+};
+
+// TraversalSubType
+struct first_side
+{
+}; // for single_side
+struct second_side
+{
+}; // for single_side
+struct alternating
+{
+}; // for both_sides
+
+// Time
+struct current_iteration
+{
+};
+struct previous_iteration
+{
+};
+
+// Why TraversalType AND TraversalSubType? TraversalSubType is a function
+// template parameter passed in to the constructor of the face iterator,
+// whereas TraversalType is a class template parameter. This lets us decide
+// at runtime whether to move along the first or second side of a bicomp (by
+// assigning a face_iterator that has been constructed with TraversalSubType
+// = first_side or second_side to a face_iterator variable) without any of
+// the virtual function overhead that comes with implementing this
+// functionality as a more structured form of type erasure. It also allows
+// a single face_iterator to be the end iterator of two iterators traversing
+// both sides of a bicomp.
+
+// ValueType is either graph_traits<Graph>::vertex_descriptor
+// or graph_traits<Graph>::edge_descriptor
+
+// forward declaration (defining defaults)
+template < typename Graph, typename FaceHandlesMap, typename ValueType,
+    typename BicompSideToTraverse = single_side,
+    typename VisitorType = lead_visitor, typename Time = current_iteration >
+class face_iterator;
+
+template < typename Graph, bool StoreEdge > struct edge_storage
+{
+};
+
+template < typename Graph > struct edge_storage< Graph, true >
+{
+    typename graph_traits< Graph >::edge_descriptor value;
+};
+
+// specialization for TraversalType = traverse_vertices
+template < typename Graph, typename FaceHandlesMap, typename ValueType,
+    typename TraversalType, typename VisitorType, typename Time >
+
+class face_iterator : public boost::iterator_facade<
+                          face_iterator< Graph, FaceHandlesMap, ValueType,
+                              TraversalType, VisitorType, Time >,
+                          ValueType, boost::forward_traversal_tag, ValueType >
+{
+public:
+    typedef typename graph_traits< Graph >::vertex_descriptor vertex_t;
+    typedef typename graph_traits< Graph >::edge_descriptor edge_t;
+    typedef face_iterator< Graph, FaceHandlesMap, ValueType, TraversalType,
+        VisitorType, Time >
+        self;
+    typedef typename FaceHandlesMap::value_type face_handle_t;
+
+    face_iterator()
+    : m_lead(graph_traits< Graph >::null_vertex())
+    , m_follow(graph_traits< Graph >::null_vertex())
+    {
+    }
+
+    template < typename TraversalSubType >
+    face_iterator(face_handle_t anchor_handle, FaceHandlesMap face_handles,
+        TraversalSubType traversal_type)
+    : m_follow(anchor_handle.get_anchor()), m_face_handles(face_handles)
+    {
+        set_lead_dispatch(anchor_handle, traversal_type);
+    }
+
+    template < typename TraversalSubType >
+    face_iterator(vertex_t anchor, FaceHandlesMap face_handles,
+        TraversalSubType traversal_type)
+    : m_follow(anchor), m_face_handles(face_handles)
+    {
+        set_lead_dispatch(m_face_handles[anchor], traversal_type);
+    }
+
+private:
+    friend class boost::iterator_core_access;
+
+    inline vertex_t get_first_vertex(
+        face_handle_t anchor_handle, current_iteration)
+    {
+        return anchor_handle.first_vertex();
+    }
+
+    inline vertex_t get_second_vertex(
+        face_handle_t anchor_handle, current_iteration)
+    {
+        return anchor_handle.second_vertex();
+    }
+
+    inline vertex_t get_first_vertex(
+        face_handle_t anchor_handle, previous_iteration)
+    {
+        return anchor_handle.old_first_vertex();
+    }
+
+    inline vertex_t get_second_vertex(
+        face_handle_t anchor_handle, previous_iteration)
+    {
+        return anchor_handle.old_second_vertex();
+    }
+
+    inline void set_lead_dispatch(face_handle_t anchor_handle, first_side)
+    {
+        m_lead = get_first_vertex(anchor_handle, Time());
+        set_edge_to_first_dispatch(anchor_handle, ValueType(), Time());
+    }
+
+    inline void set_lead_dispatch(face_handle_t anchor_handle, second_side)
+    {
+        m_lead = get_second_vertex(anchor_handle, Time());
+        set_edge_to_second_dispatch(anchor_handle, ValueType(), Time());
+    }
+
+    inline void set_edge_to_first_dispatch(
+        face_handle_t anchor_handle, edge_t, current_iteration)
+    {
+        m_edge.value = anchor_handle.first_edge();
+    }
+
+    inline void set_edge_to_second_dispatch(
+        face_handle_t anchor_handle, edge_t, current_iteration)
+    {
+        m_edge.value = anchor_handle.second_edge();
+    }
+
+    inline void set_edge_to_first_dispatch(
+        face_handle_t anchor_handle, edge_t, previous_iteration)
+    {
+        m_edge.value = anchor_handle.old_first_edge();
+    }
+
+    inline void set_edge_to_second_dispatch(
+        face_handle_t anchor_handle, edge_t, previous_iteration)
+    {
+        m_edge.value = anchor_handle.old_second_edge();
+    }
+
+    template < typename T >
+    inline void set_edge_to_first_dispatch(face_handle_t, vertex_t, T)
+    {
+    }
+
+    template < typename T >
+    inline void set_edge_to_second_dispatch(face_handle_t, vertex_t, T)
+    {
+    }
+
+    void increment()
+    {
+        face_handle_t curr_face_handle(m_face_handles[m_lead]);
+        vertex_t first = get_first_vertex(curr_face_handle, Time());
+        vertex_t second = get_second_vertex(curr_face_handle, Time());
+        if (first == m_follow)
+        {
+            m_follow = m_lead;
+            set_edge_to_second_dispatch(curr_face_handle, ValueType(), Time());
+            m_lead = second;
+        }
+        else if (second == m_follow)
+        {
+            m_follow = m_lead;
+            set_edge_to_first_dispatch(curr_face_handle, ValueType(), Time());
+            m_lead = first;
+        }
+        else
+            m_lead = m_follow = graph_traits< Graph >::null_vertex();
+    }
+
+    bool equal(self const& other) const
+    {
+        return m_lead == other.m_lead && m_follow == other.m_follow;
+    }
+
+    ValueType dereference() const
+    {
+        return dereference_dispatch(VisitorType(), ValueType());
+    }
+
+    inline ValueType dereference_dispatch(lead_visitor, vertex_t) const
+    {
+        return m_lead;
+    }
+
+    inline ValueType dereference_dispatch(follow_visitor, vertex_t) const
+    {
+        return m_follow;
+    }
+
+    inline ValueType dereference_dispatch(lead_visitor, edge_t) const
+    {
+        return m_edge.value;
+    }
+
+    inline ValueType dereference_dispatch(follow_visitor, edge_t) const
+    {
+        return m_edge.value;
+    }
+
+    vertex_t m_lead;
+    vertex_t m_follow;
+    edge_storage< Graph, boost::is_same< ValueType, edge_t >::value > m_edge;
+    FaceHandlesMap m_face_handles;
+};
+
+template < typename Graph, typename FaceHandlesMap, typename ValueType,
+    typename VisitorType, typename Time >
+class face_iterator< Graph, FaceHandlesMap, ValueType, both_sides, VisitorType,
+    Time >
+: public boost::iterator_facade< face_iterator< Graph, FaceHandlesMap,
+                                     ValueType, both_sides, VisitorType, Time >,
+      ValueType, boost::forward_traversal_tag, ValueType >
+{
+public:
+    typedef face_iterator< Graph, FaceHandlesMap, ValueType, both_sides,
+        VisitorType, Time >
+        self;
+    typedef typename graph_traits< Graph >::vertex_descriptor vertex_t;
+    typedef typename FaceHandlesMap::value_type face_handle_t;
+
+    face_iterator() {}
+
+    face_iterator(face_handle_t anchor_handle, FaceHandlesMap face_handles)
+    : first_itr(anchor_handle, face_handles, first_side())
+    , second_itr(anchor_handle, face_handles, second_side())
+    , first_is_active(true)
+    , first_increment(true)
+    {
+    }
+
+    face_iterator(vertex_t anchor, FaceHandlesMap face_handles)
+    : first_itr(face_handles[anchor], face_handles, first_side())
+    , second_itr(face_handles[anchor], face_handles, second_side())
+    , first_is_active(true)
+    , first_increment(true)
+    {
+    }
+
+private:
+    friend class boost::iterator_core_access;
+
+    typedef face_iterator< Graph, FaceHandlesMap, ValueType, single_side,
+        follow_visitor, Time >
+        inner_itr_t;
+
+    void increment()
+    {
+        if (first_increment)
+        {
+            ++first_itr;
+            ++second_itr;
+            first_increment = false;
+        }
+        else if (first_is_active)
+            ++first_itr;
+        else
+            ++second_itr;
+        first_is_active = !first_is_active;
+    }
+
+    bool equal(self const& other) const
+    {
+        // Want this iterator to be equal to the "end" iterator when at least
+        // one of the iterators has reached the root of the current bicomp.
+        // This isn't ideal, but it works.
+
+        return (first_itr == other.first_itr || second_itr == other.second_itr);
+    }
+
+    ValueType dereference() const
+    {
+        return first_is_active ? *first_itr : *second_itr;
+    }
+
+    inner_itr_t first_itr;
+    inner_itr_t second_itr;
+    inner_itr_t face_end;
+    bool first_is_active;
+    bool first_increment;
+};
+
+} /* namespace boost */
+
+#endif //__FACE_ITERATORS_HPP__