Added boost header

test/external/boost/geometry/iterators/base.hpp

@@ -0,0 +1,70 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to 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 BOOST_GEOMETRY_ITERATORS_BASE_HPP
+#define BOOST_GEOMETRY_ITERATORS_BASE_HPP
+
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/mpl/if.hpp>
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace boost { namespace geometry { namespace detail { namespace iterators
+{
+
+template
+<
+    typename DerivedClass,
+    typename Iterator,
+    typename TraversalFlag = boost::bidirectional_traversal_tag
+>
+struct iterator_base
+    : public boost::iterator_adaptor
+    <
+        DerivedClass,
+        Iterator,
+        boost::use_default,
+        typename boost::mpl::if_
+        <
+            boost::is_convertible
+            <
+                typename boost::iterator_traversal<Iterator>::type,
+                boost::random_access_traversal_tag
+            >,
+            TraversalFlag,
+            boost::use_default
+        >::type
+    >
+{
+    // Define operator cast to Iterator to be able to write things like Iterator it = myit++
+    inline operator Iterator() const
+    {
+        return this->base();
+    }
+
+    /*inline bool operator==(Iterator const& other) const
+    {
+        return this->base() == other;
+    }
+    inline bool operator!=(Iterator const& other) const
+    {
+        return ! operator==(other);
+    }*/
+};
+
+}}}} // namespace boost::geometry::detail::iterators
+#endif
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_BASE_HPP

test/external/boost/geometry/iterators/closing_iterator.hpp

@@ -0,0 +1,157 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to 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 BOOST_GEOMETRY_ITERATORS_CLOSING_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_CLOSING_ITERATOR_HPP
+
+#include <boost/range.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Iterator which iterates through a range, but adds first element at end of the range
+\tparam Range range on which this class is based on
+\ingroup iterators
+\note Use with "closing_iterator<Range> or "closing_iterator<Range const>
+        to get non-const / const behaviour
+\note This class is normally used from "closeable_view" if Close==true
+*/
+template <typename Range>
+struct closing_iterator
+    : public boost::iterator_facade
+    <
+        closing_iterator<Range>,
+        typename boost::range_value<Range>::type const,
+        boost::random_access_traversal_tag
+    >
+{
+    /// Constructor including the range it is based on
+    explicit inline closing_iterator(Range& range)
+        : m_range(&range)
+        , m_iterator(boost::begin(range))
+        , m_end(boost::end(range))
+        , m_size(boost::size(range))
+        , m_index(0)
+    {}
+
+    /// Constructor to indicate the end of a range
+    explicit inline closing_iterator(Range& range, bool)
+        : m_range(&range)
+        , m_iterator(boost::end(range))
+        , m_end(boost::end(range))
+        , m_size(boost::size(range))
+        , m_index(m_size + 1)
+    {}
+
+    /// Default constructor
+    explicit inline closing_iterator()
+        : m_range(NULL)
+        , m_size(0)
+        , m_index(0)
+    {}
+
+    inline closing_iterator<Range>& operator=(closing_iterator<Range> const& source)
+    {
+        m_range = source.m_range;
+        m_iterator = source.m_iterator;
+        m_end = source.m_end;
+        m_size = source.m_size;
+        m_index = source.m_index;
+        return *this;
+    }
+
+    typedef std::ptrdiff_t difference_type;
+
+private:
+    friend class boost::iterator_core_access;
+
+    inline typename boost::range_value<Range>::type const& dereference() const
+    {
+        return *m_iterator;
+    }
+
+    inline difference_type distance_to(closing_iterator<Range> const& other) const
+    {
+        return other.m_index - this->m_index;
+    }
+
+    inline bool equal(closing_iterator<Range> const& other) const
+    {
+        return this->m_range == other.m_range
+            && this->m_index == other.m_index;
+    }
+
+    inline void increment()
+    {
+        if (++m_index < m_size)
+        {
+            ++m_iterator;
+        }
+        else
+        {
+            update_iterator();
+        }
+    }
+
+    inline void decrement()
+    {
+        if (m_index-- < m_size)
+        {
+            --m_iterator;
+        }
+        else
+        {
+            update_iterator();
+        }
+    }
+
+    inline void advance(difference_type n)
+    {
+        if (m_index < m_size && m_index + n < m_size)
+        {
+            m_index += n;
+            m_iterator += n;
+        }
+        else
+        {
+            m_index += n;
+            update_iterator();
+        }
+    }
+
+    inline void update_iterator()
+    {
+        this->m_iterator = m_index <= m_size
+            ? boost::begin(*m_range) + (m_index % m_size)
+            : boost::end(*m_range)
+            ;
+    }
+
+    Range* m_range;
+    typename boost::range_iterator<Range>::type m_iterator;
+    typename boost::range_iterator<Range>::type m_end;
+    difference_type m_size;
+    difference_type m_index;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_CLOSING_ITERATOR_HPP

test/external/boost/geometry/iterators/ever_circling_iterator.hpp

@@ -0,0 +1,164 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to 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 BOOST_GEOMETRY_ITERATORS_EVER_CIRCLING_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_EVER_CIRCLING_ITERATOR_HPP
+
+#include <boost/range.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/geometry/iterators/base.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+    \brief Iterator which ever circles through a range
+    \tparam Iterator iterator on which this class is based on
+    \ingroup iterators
+    \details If the iterator arrives at range.end() it restarts from the
+     beginning. So it has to be stopped in another way.
+    Don't call for(....; it++) because it will turn in an endless loop
+    \note Name inspired on David Bowie's
+    "Chant Of The Ever Circling Skeletal Family"
+*/
+template <typename Iterator>
+struct ever_circling_iterator :
+    public detail::iterators::iterator_base
+    <
+        ever_circling_iterator<Iterator>,
+        Iterator
+    >
+{
+    friend class boost::iterator_core_access;
+
+    explicit inline ever_circling_iterator(Iterator begin, Iterator end,
+            bool skip_first = false)
+      : m_begin(begin)
+      , m_end(end)
+      , m_skip_first(skip_first)
+    {
+        this->base_reference() = begin;
+    }
+
+    explicit inline ever_circling_iterator(Iterator begin, Iterator end, Iterator start,
+            bool skip_first = false)
+      : m_begin(begin)
+      , m_end(end)
+      , m_skip_first(skip_first)
+    {
+        this->base_reference() = start;
+    }
+
+    /// Navigate to a certain position, should be in [start .. end], if at end
+    /// it will circle again.
+    inline void moveto(Iterator it)
+    {
+        this->base_reference() = it;
+        check_end();
+    }
+
+private:
+
+    inline void increment(bool possibly_skip = true)
+    {
+        (this->base_reference())++;
+        check_end(possibly_skip);
+    }
+
+    inline void check_end(bool possibly_skip = true)
+    {
+        if (this->base() == this->m_end)
+        {
+            this->base_reference() = this->m_begin;
+            if (m_skip_first && possibly_skip)
+            {
+                increment(false);
+            }
+        }
+    }
+
+    Iterator m_begin;
+    Iterator m_end;
+    bool m_skip_first;
+};
+
+
+
+template <typename Range>
+class ever_circling_range_iterator
+    : public boost::iterator_adaptor
+        <
+            ever_circling_range_iterator<Range>,
+            typename boost::range_iterator<Range>::type
+        >
+{
+public :
+    typedef typename boost::range_iterator<Range>::type iterator_type;
+
+    explicit inline ever_circling_range_iterator(Range& range,
+            bool skip_first = false)
+      : m_range(range)
+      , m_skip_first(skip_first)
+    {
+        this->base_reference() = boost::begin(m_range);
+    }
+
+    explicit inline ever_circling_range_iterator(Range& range, iterator_type start,
+            bool skip_first = false)
+      : m_range(range)
+      , m_skip_first(skip_first)
+    {
+        this->base_reference() = start;
+    }
+
+    /// Navigate to a certain position, should be in [start .. end], if at end
+    /// it will circle again.
+    inline void moveto(iterator_type it)
+    {
+        this->base_reference() = it;
+        check_end();
+    }
+
+private:
+
+    friend class boost::iterator_core_access;
+
+    inline void increment(bool possibly_skip = true)
+    {
+        (this->base_reference())++;
+        check_end(possibly_skip);
+    }
+
+    inline void check_end(bool possibly_skip = true)
+    {
+        if (this->base_reference() == boost::end(m_range))
+        {
+            this->base_reference() = boost::begin(m_range);
+            if (m_skip_first && possibly_skip)
+            {
+                increment(false);
+            }
+        }
+    }
+
+    Range& m_range;
+    bool m_skip_first;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_EVER_CIRCLING_ITERATOR_HPP