stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

depends/x86_64-pc-linux-gnu/include/boost/geometry/io/wkt/detail/prefix.hpp

@@ -0,0 +1,66 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 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_IO_WKT_DETAIL_PREFIX_HPP
+#define BOOST_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkt
+{
+
+struct prefix_null
+{
+    static inline const char* apply() { return ""; }
+};
+
+struct prefix_point
+{
+    static inline const char* apply() { return "POINT"; }
+};
+
+struct prefix_polygon
+{
+    static inline const char* apply() { return "POLYGON"; }
+};
+
+struct prefix_linestring
+{
+    static inline const char* apply() { return "LINESTRING"; }
+};
+
+struct prefix_multipoint
+{
+    static inline const char* apply() { return "MULTIPOINT"; }
+};
+
+struct prefix_multilinestring
+{
+    static inline const char* apply() { return "MULTILINESTRING"; }
+};
+
+struct prefix_multipolygon
+{
+    static inline const char* apply() { return "MULTIPOLYGON"; }
+};
+
+}} // namespace wkt::impl
+#endif
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP

depends/x86_64-pc-linux-gnu/include/boost/geometry/io/wkt/detail/wkt_multi.hpp

@@ -0,0 +1,56 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 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_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP
+#define BOOST_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/domains/gis/io/wkt/write.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkt
+{
+
+struct prefix_null
+{
+    static inline const char* apply() { return ""; }
+};
+
+struct prefix_multipoint
+{
+    static inline const char* apply() { return "MULTIPOINT"; }
+};
+
+struct prefix_multilinestring
+{
+    static inline const char* apply() { return "MULTILINESTRING"; }
+};
+
+struct prefix_multipolygon
+{
+    static inline const char* apply() { return "MULTIPOLYGON"; }
+};
+
+
+
+}} // namespace wkt::impl
+#endif
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP

depends/x86_64-pc-linux-gnu/include/boost/geometry/io/wkt/read.hpp

@@ -0,0 +1,905 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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_IO_WKT_READ_HPP
+#define BOOST_GEOMETRY_IO_WKT_READ_HPP
+
+#include <cstddef>
+#include <string>
+
+#include <boost/lexical_cast.hpp>
+#include <boost/tokenizer.hpp>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/size.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/exception.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/geometry_id.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/util/coordinate_cast.hpp>
+
+#include <boost/geometry/io/wkt/detail/prefix.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Exception showing things wrong with WKT parsing
+\ingroup wkt
+*/
+struct read_wkt_exception : public geometry::exception
+{
+    template <typename Iterator>
+    read_wkt_exception(std::string const& msg,
+                       Iterator const& it,
+                       Iterator const& end,
+                       std::string const& wkt)
+        : message(msg)
+        , wkt(wkt)
+    {
+        if (it != end)
+        {
+            source = " at '";
+            source += it->c_str();
+            source += "'";
+        }
+        complete = message + source + " in '" + wkt.substr(0, 100) + "'";
+    }
+
+    read_wkt_exception(std::string const& msg, std::string const& wkt)
+        : message(msg)
+        , wkt(wkt)
+    {
+        complete = message + "' in (" + wkt.substr(0, 100) + ")";
+    }
+
+    virtual ~read_wkt_exception() throw() {}
+
+    virtual const char* what() const throw()
+    {
+        return complete.c_str();
+    }
+private :
+    std::string source;
+    std::string message;
+    std::string wkt;
+    std::string complete;
+};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+// (wkt: Well Known Text, defined by OGC for all geometries and implemented by e.g. databases (MySQL, PostGIS))
+namespace detail { namespace wkt
+{
+
+typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+
+template <typename Point,
+          std::size_t Dimension = 0,
+          std::size_t DimensionCount = geometry::dimension<Point>::value>
+struct parsing_assigner
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             Point& point,
+                             std::string const& wkt)
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+
+        // Stop at end of tokens, or at "," ot ")"
+        bool finished = (it == end || *it == "," || *it == ")");
+
+        try
+        {
+            // Initialize missing coordinates to default constructor (zero)
+            // OR
+            // Use lexical_cast for conversion to double/int
+            // Note that it is much slower than atof. However, it is more standard
+            // and in parsing the change in performance falls probably away against
+            // the tokenizing
+            set<Dimension>(point, finished
+                    ? coordinate_type()
+                    : coordinate_cast<coordinate_type>::apply(*it));
+        }
+        catch(boost::bad_lexical_cast const& blc)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception(blc.what(), it, end, wkt));
+        }
+        catch(std::exception const& e)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception(e.what(), it, end, wkt));
+        }
+        catch(...)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("", it, end, wkt));
+        }
+
+        parsing_assigner<Point, Dimension + 1, DimensionCount>::apply(
+                        (finished ? it : ++it), end, point, wkt);
+    }
+};
+
+template <typename Point, std::size_t DimensionCount>
+struct parsing_assigner<Point, DimensionCount, DimensionCount>
+{
+    static inline void apply(tokenizer::iterator&,
+                             tokenizer::iterator const&,
+                             Point&,
+                             std::string const&)
+    {
+    }
+};
+
+
+
+template <typename Iterator>
+inline void handle_open_parenthesis(Iterator& it,
+                                    Iterator const& end,
+                                    std::string const& wkt)
+{
+    if (it == end || *it != "(")
+    {
+        BOOST_THROW_EXCEPTION(read_wkt_exception("Expected '('", it, end, wkt));
+    }
+    ++it;
+}
+
+
+template <typename Iterator>
+inline void handle_close_parenthesis(Iterator& it,
+                                     Iterator const& end,
+                                     std::string const& wkt)
+{
+    if (it != end && *it == ")")
+    {
+        ++it;
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(read_wkt_exception("Expected ')'", it, end, wkt));
+    }
+}
+
+template <typename Iterator>
+inline void check_end(Iterator& it,
+                      Iterator const& end,
+                      std::string const& wkt)
+{
+    if (it != end)
+    {
+        BOOST_THROW_EXCEPTION(read_wkt_exception("Too many tokens", it, end, wkt));
+    }
+}
+
+/*!
+\brief Internal, parses coordinate sequences, strings are formated like "(1 2,3 4,...)"
+\param it token-iterator, should be pre-positioned at "(", is post-positions after last ")"
+\param end end-token-iterator
+\param out Output itererator receiving coordinates
+*/
+template <typename Point>
+struct container_inserter
+{
+    // Version with output iterator
+    template <typename OutputIterator>
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             OutputIterator out)
+    {
+        handle_open_parenthesis(it, end, wkt);
+
+        Point point;
+
+        // Parse points until closing parenthesis
+
+        while (it != end && *it != ")")
+        {
+            parsing_assigner<Point>::apply(it, end, point, wkt);
+            out = point;
+            ++out;
+            if (it != end && *it == ",")
+            {
+                ++it;
+            }
+        }
+
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+template <typename Geometry,
+          closure_selector Closure = closure<Geometry>::value>
+struct stateful_range_appender
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+
+    // NOTE: Geometry is a reference
+    inline void append(Geometry geom, point_type const& point, bool)
+    {
+        geometry::append(geom, point);
+    }
+};
+
+template <typename Geometry>
+struct stateful_range_appender<Geometry, open>
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+    typedef typename boost::range_size
+        <
+            typename util::bare_type<Geometry>::type
+        >::type size_type;
+
+    BOOST_STATIC_ASSERT(( boost::is_same
+                            <
+                                typename tag<Geometry>::type,
+                                ring_tag
+                            >::value ));
+
+    inline stateful_range_appender()
+        : pt_index(0)
+    {}
+
+    // NOTE: Geometry is a reference
+    inline void append(Geometry geom, point_type const& point, bool is_next_expected)
+    {
+        bool should_append = true;
+
+        if (pt_index == 0)
+        {
+            first_point = point;
+            //should_append = true;
+        }
+        else
+        {
+            // NOTE: if there is not enough Points, they're always appended
+            should_append
+                = is_next_expected
+                || pt_index < core_detail::closure::minimum_ring_size<open>::value
+                || !detail::equals::equals_point_point(point, first_point);
+        }
+        ++pt_index;
+
+        if (should_append)
+        {
+            geometry::append(geom, point);
+        }
+    }
+
+private:
+    size_type pt_index;
+    point_type first_point;
+};
+
+// Geometry is a value-type or reference-type
+template <typename Geometry>
+struct container_appender
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Geometry out)
+    {
+        handle_open_parenthesis(it, end, wkt);
+
+        stateful_range_appender<Geometry> appender;
+
+        // Parse points until closing parenthesis
+        while (it != end && *it != ")")
+        {
+            point_type point;
+
+            parsing_assigner<point_type>::apply(it, end, point, wkt);
+
+            bool const is_next_expected = it != end && *it == ",";
+
+            appender.append(out, point, is_next_expected);
+
+            if (is_next_expected)
+            {
+                ++it;
+            }
+        }
+
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+/*!
+\brief Internal, parses a point from a string like this "(x y)"
+\note used for parsing points and multi-points
+*/
+template <typename P>
+struct point_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             P& point)
+    {
+        handle_open_parenthesis(it, end, wkt);
+        parsing_assigner<P>::apply(it, end, point, wkt);
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+template <typename Geometry>
+struct linestring_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Geometry& geometry)
+    {
+        container_appender<Geometry&>::apply(it, end, wkt, geometry);
+    }
+};
+
+
+template <typename Ring>
+struct ring_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Ring& ring)
+    {
+        // A ring should look like polygon((x y,x y,x y...))
+        // So handle the extra opening/closing parentheses
+        // and in between parse using the container-inserter
+        handle_open_parenthesis(it, end, wkt);
+        container_appender<Ring&>::apply(it, end, wkt, ring);
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+/*!
+\brief Internal, parses a polygon from a string like this "((x y,x y),(x y,x y))"
+\note used for parsing polygons and multi-polygons
+*/
+template <typename Polygon>
+struct polygon_parser
+{
+    typedef typename ring_return_type<Polygon>::type ring_return_type;
+    typedef container_appender<ring_return_type> appender;
+
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Polygon& poly)
+    {
+
+        handle_open_parenthesis(it, end, wkt);
+
+        int n = -1;
+
+        // Stop at ")"
+        while (it != end && *it != ")")
+        {
+            // Parse ring
+            if (++n == 0)
+            {
+                appender::apply(it, end, wkt, exterior_ring(poly));
+            }
+            else
+            {
+                typename ring_type<Polygon>::type ring;
+                appender::apply(it, end, wkt, ring);
+                traits::push_back
+                    <
+                        typename boost::remove_reference
+                        <
+                            typename traits::interior_mutable_type<Polygon>::type
+                        >::type
+                    >::apply(interior_rings(poly), ring);
+            }
+
+            if (it != end && *it == ",")
+            {
+                // Skip "," after ring is parsed
+                ++it;
+            }
+        }
+
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+inline bool one_of(tokenizer::iterator const& it,
+                   std::string const& value,
+                   bool& is_present)
+{
+    if (boost::iequals(*it, value))
+    {
+        is_present = true;
+        return true;
+    }
+    return false;
+}
+
+inline bool one_of(tokenizer::iterator const& it,
+                   std::string const& value,
+                   bool& present1,
+                   bool& present2)
+{
+    if (boost::iequals(*it, value))
+    {
+        present1 = true;
+        present2 = true;
+        return true;
+    }
+    return false;
+}
+
+
+inline void handle_empty_z_m(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             bool& has_empty,
+                             bool& has_z,
+                             bool& has_m)
+{
+    has_empty = false;
+    has_z = false;
+    has_m = false;
+
+    // WKT can optionally have Z and M (measured) values as in
+    // POINT ZM (1 1 5 60), POINT M (1 1 80), POINT Z (1 1 5)
+    // GGL supports any of them as coordinate values, but is not aware
+    // of any Measured value.
+    while (it != end
+           && (one_of(it, "M", has_m)
+               || one_of(it, "Z", has_z)
+               || one_of(it, "EMPTY", has_empty)
+               || one_of(it, "MZ", has_m, has_z)
+               || one_of(it, "ZM", has_z, has_m)
+               )
+           )
+    {
+        ++it;
+    }
+}
+
+/*!
+\brief Internal, starts parsing
+\param tokens boost tokens, parsed with separator " " and keeping separator "()"
+\param geometry string to compare with first token
+*/
+template <typename Geometry>
+inline bool initialize(tokenizer const& tokens,
+                       std::string const& geometry_name,
+                       std::string const& wkt,
+                       tokenizer::iterator& it,
+                       tokenizer::iterator& end)
+{
+    it = tokens.begin();
+    end = tokens.end();
+    if (it != end && boost::iequals(*it++, geometry_name))
+    {
+        bool has_empty, has_z, has_m;
+
+        handle_empty_z_m(it, end, has_empty, has_z, has_m);
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)  
+#pragma warning(disable : 4127)  
+#endif
+
+        if (has_z && dimension<Geometry>::type::value < 3)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Z only allowed for 3 or more dimensions", wkt));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+        if (has_empty)
+        {
+            check_end(it, end, wkt);
+            return false;
+        }
+        // M is ignored at all.
+
+        return true;
+    }
+    BOOST_THROW_EXCEPTION(read_wkt_exception(std::string("Should start with '") + geometry_name + "'", wkt));
+}
+
+
+template <typename Geometry, template<typename> class Parser, typename PrefixPolicy>
+struct geometry_parser
+{
+    static inline void apply(std::string const& wkt, Geometry& geometry)
+    {
+        geometry::clear(geometry);
+
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it, end;
+        if (initialize<Geometry>(tokens, PrefixPolicy::apply(), wkt, it, end))
+        {
+            Parser<Geometry>::apply(it, end, wkt, geometry);
+            check_end(it, end, wkt);
+        }
+    }
+};
+
+
+template <typename MultiGeometry, template<typename> class Parser, typename PrefixPolicy>
+struct multi_parser
+{
+    static inline void apply(std::string const& wkt, MultiGeometry& geometry)
+    {
+        traits::clear<MultiGeometry>::apply(geometry);
+
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it, end;
+        if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it, end))
+        {
+            handle_open_parenthesis(it, end, wkt);
+
+            // Parse sub-geometries
+            while(it != end && *it != ")")
+            {
+                traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1);
+                Parser
+                    <
+                        typename boost::range_value<MultiGeometry>::type
+                    >::apply(it, end, wkt, *(boost::end(geometry) - 1));
+                if (it != end && *it == ",")
+                {
+                    // Skip "," after multi-element is parsed
+                    ++it;
+                }
+            }
+
+            handle_close_parenthesis(it, end, wkt);
+        }
+
+        check_end(it, end, wkt);
+    }
+};
+
+template <typename P>
+struct noparenthesis_point_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             P& point)
+    {
+        parsing_assigner<P>::apply(it, end, point, wkt);
+    }
+};
+
+template <typename MultiGeometry, typename PrefixPolicy>
+struct multi_point_parser
+{
+    static inline void apply(std::string const& wkt, MultiGeometry& geometry)
+    {
+        traits::clear<MultiGeometry>::apply(geometry);
+
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it, end;
+
+        if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it, end))
+        {
+            handle_open_parenthesis(it, end, wkt);
+
+            // If first point definition starts with "(" then parse points as (x y)
+            // otherwise as "x y"
+            bool using_brackets = (it != end && *it == "(");
+
+            while(it != end && *it != ")")
+            {
+                traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1);
+
+                if (using_brackets)
+                {
+                    point_parser
+                        <
+                            typename boost::range_value<MultiGeometry>::type
+                        >::apply(it, end, wkt, *(boost::end(geometry) - 1));
+                }
+                else
+                {
+                    noparenthesis_point_parser
+                        <
+                            typename boost::range_value<MultiGeometry>::type
+                        >::apply(it, end, wkt, *(boost::end(geometry) - 1));
+                }
+
+                if (it != end && *it == ",")
+                {
+                    // Skip "," after point is parsed
+                    ++it;
+                }
+            }
+
+            handle_close_parenthesis(it, end, wkt);
+        }
+
+        check_end(it, end, wkt);
+    }
+};
+
+
+/*!
+\brief Supports box parsing
+\note OGC does not define the box geometry, and WKT does not support boxes.
+    However, to be generic GGL supports reading and writing from and to boxes.
+    Boxes are outputted as a standard POLYGON. GGL can read boxes from
+    a standard POLYGON, from a POLYGON with 2 points of from a BOX
+\tparam Box the box
+*/
+template <typename Box>
+struct box_parser
+{
+    static inline void apply(std::string const& wkt, Box& box)
+    {
+        bool should_close = false;
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it = tokens.begin();
+        tokenizer::iterator end = tokens.end();
+        if (it != end && boost::iequals(*it, "POLYGON"))
+        {
+            ++it;
+            bool has_empty, has_z, has_m;
+            handle_empty_z_m(it, end, has_empty, has_z, has_m);
+            if (has_empty)
+            {
+                assign_zero(box);
+                return;
+            }
+            handle_open_parenthesis(it, end, wkt);
+            should_close = true;
+        }
+        else if (it != end && boost::iequals(*it, "BOX"))
+        {
+            ++it;
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Should start with 'POLYGON' or 'BOX'", wkt));
+        }
+
+        typedef typename point_type<Box>::type point_type;
+        std::vector<point_type> points;
+        container_inserter<point_type>::apply(it, end, wkt, std::back_inserter(points));
+
+        if (should_close)
+        {
+            handle_close_parenthesis(it, end, wkt);
+        }
+        check_end(it, end, wkt);
+
+        unsigned int index = 0;
+        std::size_t n = boost::size(points);
+        if (n == 2)
+        {
+            index = 1;
+        }
+        else if (n == 4 || n == 5)
+        {
+            // In case of 4 or 5 points, we do not check the other ones, just
+            // take the opposite corner which is always 2
+            index = 2;
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Box should have 2,4 or 5 points", wkt));
+        }
+
+        geometry::detail::assign_point_to_index<min_corner>(points.front(), box);
+        geometry::detail::assign_point_to_index<max_corner>(points[index], box);
+    }
+};
+
+
+/*!
+\brief Supports segment parsing
+\note OGC does not define the segment, and WKT does not support segmentes.
+    However, it is useful to implement it, also for testing purposes
+\tparam Segment the segment
+*/
+template <typename Segment>
+struct segment_parser
+{
+    static inline void apply(std::string const& wkt, Segment& segment)
+    {
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it = tokens.begin();
+        tokenizer::iterator end = tokens.end();
+        if (it != end &&
+            (boost::iequals(*it, "SEGMENT")
+            || boost::iequals(*it, "LINESTRING") ))
+        {
+            ++it;
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Should start with 'LINESTRING' or 'SEGMENT'", wkt));
+        }
+
+        typedef typename point_type<Segment>::type point_type;
+        std::vector<point_type> points;
+        container_inserter<point_type>::apply(it, end, wkt, std::back_inserter(points));
+
+        check_end(it, end, wkt);
+
+        if (boost::size(points) == 2)
+        {
+            geometry::detail::assign_point_to_index<0>(points.front(), segment);
+            geometry::detail::assign_point_to_index<1>(points.back(), segment);
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Segment should have 2 points", wkt));
+        }
+
+    }
+};
+
+
+}} // namespace detail::wkt
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Tag, typename Geometry>
+struct read_wkt {};
+
+
+template <typename Point>
+struct read_wkt<point_tag, Point>
+    : detail::wkt::geometry_parser
+        <
+            Point,
+            detail::wkt::point_parser,
+            detail::wkt::prefix_point
+        >
+{};
+
+
+template <typename L>
+struct read_wkt<linestring_tag, L>
+    : detail::wkt::geometry_parser
+        <
+            L,
+            detail::wkt::linestring_parser,
+            detail::wkt::prefix_linestring
+        >
+{};
+
+template <typename Ring>
+struct read_wkt<ring_tag, Ring>
+    : detail::wkt::geometry_parser
+        <
+            Ring,
+            detail::wkt::ring_parser,
+            detail::wkt::prefix_polygon
+        >
+{};
+
+template <typename Geometry>
+struct read_wkt<polygon_tag, Geometry>
+    : detail::wkt::geometry_parser
+        <
+            Geometry,
+            detail::wkt::polygon_parser,
+            detail::wkt::prefix_polygon
+        >
+{};
+
+
+template <typename MultiGeometry>
+struct read_wkt<multi_point_tag, MultiGeometry>
+    : detail::wkt::multi_point_parser
+            <
+                MultiGeometry,
+                detail::wkt::prefix_multipoint
+            >
+{};
+
+template <typename MultiGeometry>
+struct read_wkt<multi_linestring_tag, MultiGeometry>
+    : detail::wkt::multi_parser
+            <
+                MultiGeometry,
+                detail::wkt::linestring_parser,
+                detail::wkt::prefix_multilinestring
+            >
+{};
+
+template <typename MultiGeometry>
+struct read_wkt<multi_polygon_tag, MultiGeometry>
+    : detail::wkt::multi_parser
+            <
+                MultiGeometry,
+                detail::wkt::polygon_parser,
+                detail::wkt::prefix_multipolygon
+            >
+{};
+
+
+// Box (Non-OGC)
+template <typename Box>
+struct read_wkt<box_tag, Box>
+    : detail::wkt::box_parser<Box>
+{};
+
+// Segment (Non-OGC)
+template <typename Segment>
+struct read_wkt<segment_tag, Segment>
+    : detail::wkt::segment_parser<Segment>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+/*!
+\brief Parses OGC Well-Known Text (\ref WKT) into a geometry (any geometry)
+\ingroup wkt
+\tparam Geometry \tparam_geometry
+\param wkt string containing \ref WKT
+\param geometry \param_geometry output geometry
+\ingroup wkt
+\qbk{[include reference/io/read_wkt.qbk]}
+*/
+template <typename Geometry>
+inline void read_wkt(std::string const& wkt, Geometry& geometry)
+{
+    geometry::concepts::check<Geometry>();
+    dispatch::read_wkt<typename tag<Geometry>::type, Geometry>::apply(wkt, geometry);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_WKT_READ_HPP

depends/x86_64-pc-linux-gnu/include/boost/geometry/io/wkt/stream.hpp

@@ -0,0 +1,38 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 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_IO_WKT_STREAM_HPP
+#define BOOST_GEOMETRY_IO_WKT_STREAM_HPP
+
+#include <boost/geometry/io/wkt/write.hpp>
+
+// This short file contains only one manipulator, streaming as WKT
+// Don't include this in any standard-included header file.
+
+// Don't use namespace boost::geometry, to enable the library to stream custom
+// geometries which are living outside the namespace boost::geometry
+
+// This is currently not documented on purpose: the Doxygen 2 QBK generator
+// should be updated w.r.t. << which in the end ruins the DocBook XML
+template<typename Char, typename Traits, typename Geometry>
+inline std::basic_ostream<Char, Traits>& operator<<
+    (
+        std::basic_ostream<Char, Traits> &os,
+        Geometry const& geom
+    )
+{
+    os << boost::geometry::wkt(geom);
+    return os;
+}
+
+#endif // BOOST_GEOMETRY_IO_WKT_STREAM_HPP

depends/x86_64-pc-linux-gnu/include/boost/geometry/io/wkt/wkt.hpp

@@ -0,0 +1,25 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 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_IO_WKT_WKT_HPP
+#define BOOST_GEOMETRY_IO_WKT_WKT_HPP
+
+#include <boost/geometry/io/wkt/read.hpp>
+#include <boost/geometry/io/wkt/write.hpp>
+
+// BSG 2011-02-03
+// We don't include stream.hpp by default. That tries to stream anything not known
+// by default (such as ttmath) and reports errors.
+// Users can include stream.hpp themselves (if they want to)
+
+#endif // BOOST_GEOMETRY_IO_WKT_WKT_HPP

depends/x86_64-pc-linux-gnu/include/boost/geometry/io/wkt/write.hpp

@@ -0,0 +1,515 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_IO_WKT_WRITE_HPP
+#define BOOST_GEOMETRY_IO_WKT_WRITE_HPP
+
+#include <ostream>
+#include <string>
+
+#include <boost/array.hpp>
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_point.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/geometries/ring.hpp>
+
+#include <boost/geometry/io/wkt/detail/prefix.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4512: 'boost::geometry::wkt_manipulator<Geometry>' : assignment operator could not be generated
+#if defined(_MSC_VER)
+#pragma warning(push)  
+#pragma warning(disable : 4512)  
+#endif
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkt
+{
+
+template <typename P, int I, int Count>
+struct stream_coordinate
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os, P const& p)
+    {
+        os << (I > 0 ? " " : "") << get<I>(p);
+        stream_coordinate<P, I + 1, Count>::apply(os, p);
+    }
+};
+
+template <typename P, int Count>
+struct stream_coordinate<P, Count, Count>
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>&, P const&)
+    {}
+};
+
+struct prefix_linestring_par
+{
+    static inline const char* apply() { return "LINESTRING("; }
+};
+
+struct prefix_ring_par_par
+{
+    // Note, double parentheses are intentional, indicating WKT ring begin/end
+    static inline const char* apply() { return "POLYGON(("; }
+};
+
+struct opening_parenthesis
+{
+    static inline const char* apply() { return "("; }
+};
+
+struct closing_parenthesis
+{
+    static inline const char* apply() { return ")"; }
+};
+
+struct double_closing_parenthesis
+{
+    static inline const char* apply() { return "))"; }
+};
+
+/*!
+\brief Stream points as \ref WKT
+*/
+template <typename Point, typename Policy>
+struct wkt_point
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os, Point const& p)
+    {
+        os << Policy::apply() << "(";
+        stream_coordinate<Point, 0, dimension<Point>::type::value>::apply(os, p);
+        os << ")";
+    }
+};
+
+/*!
+\brief Stream ranges as WKT
+\note policy is used to stream prefix/postfix, enabling derived classes to override this
+*/
+template <typename Range, typename PrefixPolicy, typename SuffixPolicy>
+struct wkt_range
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Range const& range, bool force_closed)
+    {
+        typedef typename boost::range_iterator<Range const>::type iterator_type;
+
+        typedef stream_coordinate
+            <
+                point_type, 0, dimension<point_type>::type::value
+            > stream_type;
+
+        bool first = true;
+
+        os << PrefixPolicy::apply();
+
+        // TODO: check EMPTY here
+
+        iterator_type begin = boost::begin(range);
+        iterator_type end = boost::end(range);
+        for (iterator_type it = begin; it != end; ++it)
+        {
+            os << (first ? "" : ",");
+            stream_type::apply(os, *it);
+            first = false;
+        }
+
+        // optionally, close range to ring by repeating the first point
+        if (force_closed 
+            && boost::size(range) > 1
+            && detail::disjoint::disjoint_point_point(*begin, *(end - 1)))
+        {
+            os << ",";
+            stream_type::apply(os, *begin);
+        }
+
+        os << SuffixPolicy::apply();
+    }
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Range const& range)
+    {
+        apply(os, range, false);
+    }
+
+private:
+    typedef typename boost::range_value<Range>::type point_type;
+};
+
+/*!
+\brief Stream sequence of points as WKT-part, e.g. (1 2),(3 4)
+\note Used in polygon, all multi-geometries
+*/
+template <typename Range>
+struct wkt_sequence
+    : wkt_range
+        <
+            Range,
+            opening_parenthesis,
+            closing_parenthesis
+        >
+{};
+
+template <typename Polygon, typename PrefixPolicy>
+struct wkt_poly
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Polygon const& poly)
+    {
+        typedef typename ring_type<Polygon const>::type ring;
+        bool const force_closed = true;
+
+        os << PrefixPolicy::apply();
+        // TODO: check EMPTY here
+        os << "(";
+        wkt_sequence<ring>::apply(os, exterior_ring(poly), force_closed);
+
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(poly);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            os << ",";
+            wkt_sequence<ring>::apply(os, *it, force_closed);
+        }
+        os << ")";
+    }
+};
+
+template <typename Multi, typename StreamPolicy, typename PrefixPolicy>
+struct wkt_multi
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Multi const& geometry)
+    {
+        os << PrefixPolicy::apply();
+        // TODO: check EMPTY here
+        os << "(";
+
+        for (typename boost::range_iterator<Multi const>::type
+                    it = boost::begin(geometry);
+            it != boost::end(geometry);
+            ++it)
+        {
+            if (it != boost::begin(geometry))
+            {
+                os << ",";
+            }
+            StreamPolicy::apply(os, *it);
+        }
+
+        os << ")";
+    }
+};
+
+template <typename Box>
+struct wkt_box
+{
+    typedef typename point_type<Box>::type point_type;
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Box const& box)
+    {
+        // Convert to ring, then stream
+        typedef model::ring<point_type> ring_type;
+        ring_type ring;
+        geometry::convert(box, ring);
+        os << "POLYGON(";
+        wkt_sequence<ring_type>::apply(os, ring);
+        os << ")";
+    }
+
+    private:
+
+        inline wkt_box()
+        {
+            // Only streaming of boxes with two dimensions is support, otherwise it is a polyhedron!
+            //assert_dimension<B, 2>();
+        }
+};
+
+
+template <typename Segment>
+struct wkt_segment
+{
+    typedef typename point_type<Segment>::type point_type;
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Segment const& segment)
+    {
+        // Convert to two points, then stream
+        typedef boost::array<point_type, 2> sequence;
+
+        sequence points;
+        geometry::detail::assign_point_from_index<0>(segment, points[0]);
+        geometry::detail::assign_point_from_index<1>(segment, points[1]);
+
+        // In Boost.Geometry a segment is represented
+        // in WKT-format like (for 2D): LINESTRING(x y,x y)
+        os << "LINESTRING";
+        wkt_sequence<sequence>::apply(os, points);
+    }
+
+    private:
+
+        inline wkt_segment()
+        {}
+};
+
+}} // namespace detail::wkt
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct wkt: not_implemented<Tag>
+{};
+
+template <typename Point>
+struct wkt<Point, point_tag>
+    : detail::wkt::wkt_point
+        <
+            Point,
+            detail::wkt::prefix_point
+        >
+{};
+
+template <typename Linestring>
+struct wkt<Linestring, linestring_tag>
+    : detail::wkt::wkt_range
+        <
+            Linestring,
+            detail::wkt::prefix_linestring_par,
+            detail::wkt::closing_parenthesis
+        >
+{};
+
+/*!
+\brief Specialization to stream a box as WKT
+\details A "box" does not exist in WKT.
+It is therefore streamed as a polygon
+*/
+template <typename Box>
+struct wkt<Box, box_tag>
+    : detail::wkt::wkt_box<Box>
+{};
+
+template <typename Segment>
+struct wkt<Segment, segment_tag>
+    : detail::wkt::wkt_segment<Segment>
+{};
+
+/*!
+\brief Specialization to stream a ring as WKT
+\details A ring or "linear_ring" does not exist in WKT.
+A ring is equivalent to a polygon without inner rings
+It is therefore streamed as a polygon
+*/
+template <typename Ring>
+struct wkt<Ring, ring_tag>
+    : detail::wkt::wkt_range
+        <
+            Ring,
+            detail::wkt::prefix_ring_par_par,
+            detail::wkt::double_closing_parenthesis
+        >
+{};
+
+/*!
+\brief Specialization to stream polygon as WKT
+*/
+template <typename Polygon>
+struct wkt<Polygon, polygon_tag>
+    : detail::wkt::wkt_poly
+        <
+            Polygon,
+            detail::wkt::prefix_polygon
+        >
+{};
+
+template <typename Multi>
+struct wkt<Multi, multi_point_tag>
+    : detail::wkt::wkt_multi
+        <
+            Multi,
+            detail::wkt::wkt_point
+                <
+                    typename boost::range_value<Multi>::type,
+                    detail::wkt::prefix_null
+                >,
+            detail::wkt::prefix_multipoint
+        >
+{};
+
+template <typename Multi>
+struct wkt<Multi, multi_linestring_tag>
+    : detail::wkt::wkt_multi
+        <
+            Multi,
+            detail::wkt::wkt_sequence
+                <
+                    typename boost::range_value<Multi>::type
+                >,
+            detail::wkt::prefix_multilinestring
+        >
+{};
+
+template <typename Multi>
+struct wkt<Multi, multi_polygon_tag>
+    : detail::wkt::wkt_multi
+        <
+            Multi,
+            detail::wkt::wkt_poly
+                <
+                    typename boost::range_value<Multi>::type,
+                    detail::wkt::prefix_null
+                >,
+            detail::wkt::prefix_multipolygon
+        >
+{};
+
+
+template <typename Geometry>
+struct devarianted_wkt
+{
+    template <typename OutputStream>
+    static inline void apply(OutputStream& os, Geometry const& geometry)
+    {
+        wkt<Geometry>::apply(os, geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct devarianted_wkt<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename OutputStream>
+    struct visitor: static_visitor<void>
+    {
+        OutputStream& m_os;
+
+        visitor(OutputStream& os)
+            : m_os(os)
+        {}
+
+        template <typename Geometry>
+        inline void operator()(Geometry const& geometry) const
+        {
+            devarianted_wkt<Geometry>::apply(m_os, geometry);
+        }
+    };
+
+    template <typename OutputStream>
+    static inline void apply(
+        OutputStream& os,
+        variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry
+    )
+    {
+        boost::apply_visitor(visitor<OutputStream>(os), geometry);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+/*!
+\brief Generic geometry template manipulator class, takes corresponding output class from traits class
+\ingroup wkt
+\details Stream manipulator, streams geometry classes as \ref WKT streams
+\par Example:
+Small example showing how to use the wkt class
+\dontinclude doxygen_1.cpp
+\skip example_as_wkt_point
+\line {
+\until }
+*/
+template <typename Geometry>
+class wkt_manipulator
+{
+public:
+
+    inline wkt_manipulator(Geometry const& g)
+        : m_geometry(g)
+    {}
+
+    template <typename Char, typename Traits>
+    inline friend std::basic_ostream<Char, Traits>& operator<<(
+            std::basic_ostream<Char, Traits>& os,
+            wkt_manipulator const& m)
+    {
+        dispatch::devarianted_wkt<Geometry>::apply(os, m.m_geometry);
+        os.flush();
+        return os;
+    }
+
+private:
+    Geometry const& m_geometry;
+};
+
+/*!
+\brief Main WKT-streaming function
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\ingroup wkt
+\qbk{[include reference/io/wkt.qbk]}
+*/
+template <typename Geometry>
+inline wkt_manipulator<Geometry> wkt(Geometry const& geometry)
+{
+    concepts::check<Geometry const>();
+
+    return wkt_manipulator<Geometry>(geometry);
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)  
+#endif
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_WKT_WRITE_HPP