Ticket #9066: complete-extensions-gis-io-wkb-with-multi.patch

boost/geometry/algorithms/equals.hpp

@@ -33 +33 @@
 // For trivial checks
 #include <boost/geometry/algorithms/area.hpp>
 #include <boost/geometry/algorithms/length.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
 #include <boost/geometry/util/math.hpp>
 #include <boost/geometry/util/select_coordinate_type.hpp>
 #include <boost/geometry/util/select_most_precise.hpp>
@@ -50 +51 @@
 namespace detail { namespace equals
 {
 
+struct num_points_check
+{
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2)
+    {
+        return geometry::math::equals(
+                geometry::num_points(geometry1),
+                geometry::num_points(geometry2));
+    }
+};
 
 template
 <

boost/geometry/extensions/gis/io/wkb/detail/ogc.hpp

@@ -68 +68 @@
     {
         point      = 1,
         linestring = 2,
-        polygon    = 3
-
-        // TODO: Not implemented
-        //multipoint = 4,
-        //multilinestring = 5,
-        //multipolygon = 6,
+        polygon    = 3,
+        multipoint = 4,
+        multilinestring = 5,
+        multipolygon = 6,
         //collection = 7
     };
 };

boost/geometry/extensions/gis/io/wkb/detail/parser.hpp

@@ -107 +107 @@
         byte_order_type::enum_t order)
     {
         boost::uint32_t value;
-        if (value_parser<boost::uint32_t>::parse(it, end, value, order))
+        if (!value_parser<boost::uint32_t>::parse(it, end, value, order))
         {
-            // TODO: Refine the test when multi* geometries are supported
-
-            boost::uint32_t id = value & 0xff;
-            if (geometry_type::polygon >= id)
-            {
-                type = geometry_type::enum_t(id);
-                return true;
-            }
+            return false;
         }
-        return false;
+        
+        // TODO: The 0xff mask is to filter out PostGIS EWKB bits from OGC 2D types,
+        // but this won't work with OGC WKB codes for Z, M, ZM.
+        boost::uint32_t id = value & 0xff;
+        type = geometry_type::enum_t(id);
+        
+        return true;
     }
 };
 
@@ -163 +162 @@
     }
 };
 
-template <typename P>
+template <typename Point>
 struct point_parser
 {
     template <typename Iterator>
-    static bool parse(Iterator& it, Iterator end, P& point, byte_order_type::enum_t order)
+    static bool parse(Iterator& it, Iterator end, Point& point, byte_order_type::enum_t order)
     {
-        // TODO: mloskot - Add assert on point dimension, 2d only
-
         geometry_type::enum_t type;
-        if (geometry_type_parser::parse(it, end, type, order))
+        
+        if (!geometry_type_parser::parse(it, end, type, order))
         {
-            if (geometry_type::point == type && it != end)
-            {
-                parsing_assigner<P, 0, dimension<P>::value>::run(it, end, point, order);
-            }
-            return true;
+            return false;
         }
-        return false;
+        
+        if (geometry_type::point != type)
+        {
+            return false;
+        }
+        
+        // Check that the number of double values in the stream is equal
+        // or greater than the number of expected values in the point
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        
+        size_type const container_byte_size = dimension<Point>::value * sizeof(double);
+        size_type const stream_byte_size = std::distance(it,end);
+        
+        assert(stream_byte_size >= container_byte_size);
+        
+        parsing_assigner<Point, 0, dimension<Point>::value>::run(it, end, point, order);
+        
+        return true;
     }
 };
 
@@ -188 +200 @@
 struct point_container_parser
 {
     template <typename Iterator>
-    static bool parse(Iterator& it, Iterator end, C& container, byte_order_type::enum_t order)
+    static bool parse(Iterator& it, Iterator end, C& container, byte_order_type::enum_t order, boost::uint32_t num_points)
     {
         typedef typename point_type<C>::type point_type;
 
-        boost::uint32_t num_points(0);
-        if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
-        {
-            return false;
-        }
-
         typedef typename std::iterator_traits<Iterator>::difference_type size_type;
         assert(num_points <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
 
         size_type const container_size = static_cast<size_type>(num_points);
-        size_type const point_size = dimension<point_type>::value * sizeof(double);
 
-        if (std::distance(it, end) >= (container_size * point_size))
+        point_type point_buffer;
+        std::back_insert_iterator<C> output(std::back_inserter(container));
+
+        // Read coordinates into point and append point to container
+        size_type points_parsed = 0;
+        while (points_parsed < container_size && it != end)
         {
-            point_type point_buffer;
-            std::back_insert_iterator<C> output(std::back_inserter(container));
-
-            // Read coordinates into point and append point to line (ring)
-            size_type points_parsed = 0;
-            while (points_parsed < container_size && it != end)
-            {
-                parsing_assigner<point_type, 0, dimension<point_type>::value>::run(it, end, point_buffer, order);
-                output = point_buffer;
-                ++output;
-                ++points_parsed;
-            }
-
-            if (container_size != points_parsed)
-            {
-                return false;
-            }
+            parsing_assigner<point_type, 0, dimension<point_type>::value>::run(it, end, point_buffer, order);
+            output = point_buffer;
+            ++output;
+            ++points_parsed;
         }
 
         return true;
@@ -248 +245 @@
             return false;
         }
 
-        assert(it != end);
-        return point_container_parser<L>::parse(it, end, linestring, order);
+        boost::uint32_t num_points(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
+        {
+            return false;
+        }
+        
+        // Check that the number of double values in the stream is equal
+        // or greater than the number of expected values in the linestring
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        
+        size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double);
+        size_type const stream_byte_size = std::distance(it,end);
+        
+        assert(stream_byte_size >= container_byte_size);
+        
+        return point_container_parser<L>::parse(it, end, linestring, order, num_points);
     }
 };
 
@@ -275 +287 @@
         typedef typename ring_type<Polygon>::type ring_type;
 
         std::size_t rings_parsed = 0;
-        while (rings_parsed < num_rings && it != end) //while (rings_parsed < num_rings && it != end)
+        
+        while (rings_parsed < num_rings && it != end)
         {
+            
+            boost::uint32_t num_points(0);
+            if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
+            {
+                return false;
+            }
+            
             if (0 == rings_parsed)
             {
                 ring_type& ring0 = exterior_ring(polygon);
-                if (!point_container_parser<ring_type>::parse(it, end, ring0, order))
+                
+                if (!point_container_parser<ring_type>::parse(it, end, ring0, order, num_points))
                 {
                     return false;
                 }
@@ -289 +310 @@
             {
                 interior_rings(polygon).resize(rings_parsed);
                 ring_type& ringN = interior_rings(polygon).back();
-                if (!point_container_parser<ring_type>::parse(it, end, ringN, order))
+                
+                if (!point_container_parser<ring_type>::parse(it, end, ringN, order, num_points))
                 {
                     return false;
                 }
             }
+
             ++rings_parsed;
         }
 
-        if (num_rings != rings_parsed)
-        {
-            return false;
-        }
-
         return true;
     }
 };

boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_DETAIL_PARSER_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+
+#include <boost/geometry/extensions/gis/io/wkb/detail/endian.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/ogc.hpp>
+
+#include <boost/geometry/multi/core/point_type.hpp>
+#include <boost/geometry/multi/core/ring_type.hpp>
+
+#include <boost/geometry/multi/core/interior_rings.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkb
+{
+
+template <typename MultiPoint>
+struct multipoint_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPoint& multipoint, byte_order_type::enum_t order)
+    {
+        typedef typename point_type<MultiPoint>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipoint != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_points(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
+        {
+            return false;
+        }
+        
+        // Check that the number of double values in the stream is equal
+        // or greater than the number of expected values in the multipoint
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        
+        size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double)
+                                            + num_points * sizeof(boost::uint8_t)
+                                            + num_points * sizeof(boost::uint32_t);
+        
+        size_type const stream_byte_size = std::distance(it,end);
+        
+        assert(stream_byte_size >= container_byte_size);
+        
+        point_type point_buffer;
+        std::back_insert_iterator<MultiPoint> output(std::back_inserter(multipoint));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_points <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t points_parsed = 0;
+        while (points_parsed < num_points && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t point_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, point_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t point_type_type;
+            if (!geometry_type_parser::parse(it, end, point_type_type, point_byte_order))
+            {
+                return false;
+            }
+            
+            parsing_assigner<point_type, 0, dimension<point_type>::value>::run(it, end, point_buffer, point_byte_order);
+            
+            output = point_buffer;
+            
+            ++output;
+            ++points_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiLinestring>
+struct multilinestring_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiLinestring& multilinestring, byte_order_type::enum_t order)
+    {
+        typedef typename MultiLinestring::value_type linestring_type;
+        typedef typename point_type<MultiLinestring>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multilinestring != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_linestrings(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_linestrings, order))
+        {
+            return false;
+        }
+        
+        linestring_type linestring_buffer;
+        std::back_insert_iterator<MultiLinestring> output(std::back_inserter(multilinestring));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_linestrings <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t linestrings_parsed = 0;
+        while (linestrings_parsed < num_linestrings && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t linestring_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::linestring != type)
+            {
+                return false;
+            }
+            
+            boost::uint32_t num_points(0);
+            if (!value_parser<boost::uint32_t>::parse(it, end, num_points, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            // Check that the number of double values in the stream is equal
+            // or greater than the number of expected values in the linestring
+            
+            typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+            
+            size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double);
+            size_type const stream_byte_size = std::distance(it,end);
+            
+            assert(stream_byte_size >= container_byte_size);
+            
+            return point_container_parser<linestring_type>::parse(it, end, linestring_buffer, linestring_byte_order, num_points);
+            
+            output = linestring_buffer;
+            
+            ++output;
+            ++linestrings_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiPolygon>
+struct multipolygon_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPolygon& multipolygon, byte_order_type::enum_t order)
+    {
+        typedef typename MultiPolygon::value_type polygon_type;
+        typedef typename ring_type<MultiPolygon>::type ring_type;
+        
+        geometry_type::enum_t multipolygontype;
+        if (!geometry_type_parser::parse(it, end, multipolygontype, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipolygon != multipolygontype)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_polygons(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_polygons, order))
+        {
+            return false;
+        }
+        
+        polygon_type polygon_buffer;
+        std::back_insert_iterator<MultiPolygon> output(std::back_inserter(multipolygon));
+        
+        std::size_t polygons_parsed = 0;
+        while(polygons_parsed < num_polygons && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t polygon_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::polygon != type)
+            {
+                return false;
+            }
+
+            boost::uint32_t num_rings(0);
+            if (geometry_type::polygon != type ||
+                !value_parser<boost::uint32_t>::parse(it, end, num_rings, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            std::size_t rings_parsed = 0;
+            
+            while (rings_parsed < num_rings && it != end)
+            {
+                boost::uint32_t num_points(0);
+                if (!value_parser<boost::uint32_t>::parse(it, end, num_points, polygon_byte_order))
+                {
+                    return false;
+                }
+                
+                if (0 == rings_parsed)
+                {
+                    ring_type& ring0 = exterior_ring(polygon_buffer);
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ring0, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    interior_rings(polygon_buffer).resize(rings_parsed);
+                    ring_type& ringN = interior_rings(polygon_buffer).back();
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ringN, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                ++rings_parsed;
+            }
+            output = polygon_buffer;
+            ++output;
+        }
+        
+        return true;
+    }
+};
+
+}} // namespace detail::wkb
+#endif // DOXYGEN_NO_IMPL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP

boost/geometry/extensions/multi/gis/io/wkb/read_wkb.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_READ_WKB_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP
+
+#include <iterator>
+
+#include <boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/read_wkb.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry>
+struct read_wkb<multi_point_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipoint_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_linestring_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multilinestring_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_polygon_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipolygon_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP

boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_DETAIL_PARSER_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+
+#include <boost/geometry/extensions/gis/io/wkb/detail/endian.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/ogc.hpp>
+
+#include <boost/geometry/multi/core/point_type.hpp>
+#include <boost/geometry/multi/core/ring_type.hpp>
+
+#include <boost/geometry/multi/core/interior_rings.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkb
+{
+
+template <typename MultiPoint>
+struct multipoint_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPoint& multipoint, byte_order_type::enum_t order)
+    {
+        typedef typename point_type<MultiPoint>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipoint != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_points(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
+        {
+            return false;
+        }
+        
+        // Check that the number of double values in the stream is equal
+        // or greater than the number of expected values in the multipoint
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        
+        size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double)
+                                            + num_points * sizeof(boost::uint8_t)
+                                            + num_points * sizeof(boost::uint32_t);
+        
+        size_type const stream_byte_size = std::distance(it,end);
+        
+        assert(stream_byte_size >= container_byte_size);
+        
+        point_type point_buffer;
+        std::back_insert_iterator<MultiPoint> output(std::back_inserter(multipoint));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_points <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t points_parsed = 0;
+        while (points_parsed < num_points && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t point_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, point_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t point_type_type;
+            if (!geometry_type_parser::parse(it, end, point_type_type, point_byte_order))
+            {
+                return false;
+            }
+            
+            parsing_assigner<point_type, 0, dimension<point_type>::value>::run(it, end, point_buffer, point_byte_order);
+            
+            output = point_buffer;
+            
+            ++output;
+            ++points_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiLinestring>
+struct multilinestring_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiLinestring& multilinestring, byte_order_type::enum_t order)
+    {
+        typedef typename MultiLinestring::value_type linestring_type;
+        typedef typename point_type<MultiLinestring>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multilinestring != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_linestrings(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_linestrings, order))
+        {
+            return false;
+        }
+        
+        linestring_type linestring_buffer;
+        std::back_insert_iterator<MultiLinestring> output(std::back_inserter(multilinestring));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_linestrings <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t linestrings_parsed = 0;
+        while (linestrings_parsed < num_linestrings && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t linestring_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::linestring != type)
+            {
+                return false;
+            }
+            
+            boost::uint32_t num_points(0);
+            if (!value_parser<boost::uint32_t>::parse(it, end, num_points, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            // Check that the number of double values in the stream is equal
+            // or greater than the number of expected values in the linestring
+            
+            typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+            
+            size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double);
+            size_type const stream_byte_size = std::distance(it,end);
+            
+            assert(stream_byte_size >= container_byte_size);
+            
+            return point_container_parser<linestring_type>::parse(it, end, linestring_buffer, linestring_byte_order, num_points);
+            
+            output = linestring_buffer;
+            
+            ++output;
+            ++linestrings_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiPolygon>
+struct multipolygon_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPolygon& multipolygon, byte_order_type::enum_t order)
+    {
+        typedef typename MultiPolygon::value_type polygon_type;
+        typedef typename ring_type<MultiPolygon>::type ring_type;
+        
+        geometry_type::enum_t multipolygontype;
+        if (!geometry_type_parser::parse(it, end, multipolygontype, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipolygon != multipolygontype)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_polygons(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_polygons, order))
+        {
+            return false;
+        }
+        
+        polygon_type polygon_buffer;
+        std::back_insert_iterator<MultiPolygon> output(std::back_inserter(multipolygon));
+        
+        std::size_t polygons_parsed = 0;
+        while(polygons_parsed < num_polygons && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t polygon_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::polygon != type)
+            {
+                return false;
+            }
+
+            boost::uint32_t num_rings(0);
+            if (geometry_type::polygon != type ||
+                !value_parser<boost::uint32_t>::parse(it, end, num_rings, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            std::size_t rings_parsed = 0;
+            
+            while (rings_parsed < num_rings && it != end)
+            {
+                boost::uint32_t num_points(0);
+                if (!value_parser<boost::uint32_t>::parse(it, end, num_points, polygon_byte_order))
+                {
+                    return false;
+                }
+                
+                if (0 == rings_parsed)
+                {
+                    ring_type& ring0 = exterior_ring(polygon_buffer);
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ring0, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    interior_rings(polygon_buffer).resize(rings_parsed);
+                    ring_type& ringN = interior_rings(polygon_buffer).back();
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ringN, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                ++rings_parsed;
+            }
+            output = polygon_buffer;
+            ++output;
+        }
+        
+        return true;
+    }
+};
+
+}} // namespace detail::wkb
+#endif // DOXYGEN_NO_IMPL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP

boost/geometry/extensions/multi/gis/io/wkb/read_wkb.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_READ_WKB_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP
+
+#include <iterator>
+
+#include <boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/read_wkb.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry>
+struct read_wkb<multi_point_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipoint_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_linestring_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multilinestring_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_polygon_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipolygon_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP

boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_DETAIL_PARSER_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+
+#include <boost/geometry/extensions/gis/io/wkb/detail/endian.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/ogc.hpp>
+
+#include <boost/geometry/multi/core/point_type.hpp>
+#include <boost/geometry/multi/core/ring_type.hpp>
+
+#include <boost/geometry/multi/core/interior_rings.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkb
+{
+
+template <typename MultiPoint>
+struct multipoint_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPoint& multipoint, byte_order_type::enum_t order)
+    {
+        typedef typename point_type<MultiPoint>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipoint != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_points(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
+        {
+            return false;
+        }
+        
+        // Check that the number of double values in the stream is equal
+        // or greater than the number of expected values in the multipoint
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        
+        size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double)
+                                            + num_points * sizeof(boost::uint8_t)
+                                            + num_points * sizeof(boost::uint32_t);
+        
+        size_type const stream_byte_size = std::distance(it,end);
+        
+        assert(stream_byte_size >= container_byte_size);
+        
+        point_type point_buffer;
+        std::back_insert_iterator<MultiPoint> output(std::back_inserter(multipoint));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_points <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t points_parsed = 0;
+        while (points_parsed < num_points && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t point_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, point_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t point_type_type;
+            if (!geometry_type_parser::parse(it, end, point_type_type, point_byte_order))
+            {
+                return false;
+            }
+            
+            parsing_assigner<point_type, 0, dimension<point_type>::value>::run(it, end, point_buffer, point_byte_order);
+            
+            output = point_buffer;
+            
+            ++output;
+            ++points_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiLinestring>
+struct multilinestring_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiLinestring& multilinestring, byte_order_type::enum_t order)
+    {
+        typedef typename MultiLinestring::value_type linestring_type;
+        typedef typename point_type<MultiLinestring>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multilinestring != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_linestrings(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_linestrings, order))
+        {
+            return false;
+        }
+        
+        linestring_type linestring_buffer;
+        std::back_insert_iterator<MultiLinestring> output(std::back_inserter(multilinestring));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_linestrings <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t linestrings_parsed = 0;
+        while (linestrings_parsed < num_linestrings && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t linestring_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::linestring != type)
+            {
+                return false;
+            }
+            
+            boost::uint32_t num_points(0);
+            if (!value_parser<boost::uint32_t>::parse(it, end, num_points, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            // Check that the number of double values in the stream is equal
+            // or greater than the number of expected values in the linestring
+            
+            typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+            
+            size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double);
+            size_type const stream_byte_size = std::distance(it,end);
+            
+            assert(stream_byte_size >= container_byte_size);
+            
+            return point_container_parser<linestring_type>::parse(it, end, linestring_buffer, linestring_byte_order, num_points);
+            
+            output = linestring_buffer;
+            
+            ++output;
+            ++linestrings_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiPolygon>
+struct multipolygon_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPolygon& multipolygon, byte_order_type::enum_t order)
+    {
+        typedef typename MultiPolygon::value_type polygon_type;
+        typedef typename ring_type<MultiPolygon>::type ring_type;
+        
+        geometry_type::enum_t multipolygontype;
+        if (!geometry_type_parser::parse(it, end, multipolygontype, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipolygon != multipolygontype)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_polygons(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_polygons, order))
+        {
+            return false;
+        }
+        
+        polygon_type polygon_buffer;
+        std::back_insert_iterator<MultiPolygon> output(std::back_inserter(multipolygon));
+        
+        std::size_t polygons_parsed = 0;
+        while(polygons_parsed < num_polygons && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t polygon_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::polygon != type)
+            {
+                return false;
+            }
+
+            boost::uint32_t num_rings(0);
+            if (geometry_type::polygon != type ||
+                !value_parser<boost::uint32_t>::parse(it, end, num_rings, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            std::size_t rings_parsed = 0;
+            
+            while (rings_parsed < num_rings && it != end)
+            {
+                boost::uint32_t num_points(0);
+                if (!value_parser<boost::uint32_t>::parse(it, end, num_points, polygon_byte_order))
+                {
+                    return false;
+                }
+                
+                if (0 == rings_parsed)
+                {
+                    ring_type& ring0 = exterior_ring(polygon_buffer);
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ring0, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    interior_rings(polygon_buffer).resize(rings_parsed);
+                    ring_type& ringN = interior_rings(polygon_buffer).back();
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ringN, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                ++rings_parsed;
+            }
+            output = polygon_buffer;
+            ++output;
+        }
+        
+        return true;
+    }
+};
+
+}} // namespace detail::wkb
+#endif // DOXYGEN_NO_IMPL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP

boost/geometry/extensions/multi/gis/io/wkb/read_wkb.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_READ_WKB_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP
+
+#include <iterator>
+
+#include <boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/read_wkb.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry>
+struct read_wkb<multi_point_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipoint_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_linestring_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multilinestring_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_polygon_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipolygon_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP

boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_DETAIL_PARSER_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+
+#include <boost/geometry/extensions/gis/io/wkb/detail/endian.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/ogc.hpp>
+
+#include <boost/geometry/multi/core/point_type.hpp>
+#include <boost/geometry/multi/core/ring_type.hpp>
+
+#include <boost/geometry/multi/core/interior_rings.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkb
+{
+
+template <typename MultiPoint>
+struct multipoint_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPoint& multipoint, byte_order_type::enum_t order)
+    {
+        typedef typename point_type<MultiPoint>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipoint != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_points(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
+        {
+            return false;
+        }
+        
+        // Check that the number of double values in the stream is equal
+        // or greater than the number of expected values in the multipoint
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        
+        size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double)
+                                            + num_points * sizeof(boost::uint8_t)
+                                            + num_points * sizeof(boost::uint32_t);
+        
+        size_type const stream_byte_size = std::distance(it,end);
+        
+        assert(stream_byte_size >= container_byte_size);
+        
+        point_type point_buffer;
+        std::back_insert_iterator<MultiPoint> output(std::back_inserter(multipoint));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_points <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t points_parsed = 0;
+        while (points_parsed < num_points && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t point_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, point_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t point_type_type;
+            if (!geometry_type_parser::parse(it, end, point_type_type, point_byte_order))
+            {
+                return false;
+            }
+            
+            parsing_assigner<point_type, 0, dimension<point_type>::value>::run(it, end, point_buffer, point_byte_order);
+            
+            output = point_buffer;
+            
+            ++output;
+            ++points_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiLinestring>
+struct multilinestring_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiLinestring& multilinestring, byte_order_type::enum_t order)
+    {
+        typedef typename MultiLinestring::value_type linestring_type;
+        typedef typename point_type<MultiLinestring>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multilinestring != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_linestrings(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_linestrings, order))
+        {
+            return false;
+        }
+        
+        linestring_type linestring_buffer;
+        std::back_insert_iterator<MultiLinestring> output(std::back_inserter(multilinestring));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_linestrings <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t linestrings_parsed = 0;
+        while (linestrings_parsed < num_linestrings && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t linestring_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::linestring != type)
+            {
+                return false;
+            }
+            
+            boost::uint32_t num_points(0);
+            if (!value_parser<boost::uint32_t>::parse(it, end, num_points, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            // Check that the number of double values in the stream is equal
+            // or greater than the number of expected values in the linestring
+            
+            typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+            
+            size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double);
+            size_type const stream_byte_size = std::distance(it,end);
+            
+            assert(stream_byte_size >= container_byte_size);
+            
+            return point_container_parser<linestring_type>::parse(it, end, linestring_buffer, linestring_byte_order, num_points);
+            
+            output = linestring_buffer;
+            
+            ++output;
+            ++linestrings_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiPolygon>
+struct multipolygon_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPolygon& multipolygon, byte_order_type::enum_t order)
+    {
+        typedef typename MultiPolygon::value_type polygon_type;
+        typedef typename ring_type<MultiPolygon>::type ring_type;
+        
+        geometry_type::enum_t multipolygontype;
+        if (!geometry_type_parser::parse(it, end, multipolygontype, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipolygon != multipolygontype)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_polygons(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_polygons, order))
+        {
+            return false;
+        }
+        
+        polygon_type polygon_buffer;
+        std::back_insert_iterator<MultiPolygon> output(std::back_inserter(multipolygon));
+        
+        std::size_t polygons_parsed = 0;
+        while(polygons_parsed < num_polygons && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t polygon_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::polygon != type)
+            {
+                return false;
+            }
+
+            boost::uint32_t num_rings(0);
+            if (geometry_type::polygon != type ||
+                !value_parser<boost::uint32_t>::parse(it, end, num_rings, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            std::size_t rings_parsed = 0;
+            
+            while (rings_parsed < num_rings && it != end)
+            {
+                boost::uint32_t num_points(0);
+                if (!value_parser<boost::uint32_t>::parse(it, end, num_points, polygon_byte_order))
+                {
+                    return false;
+                }
+                
+                if (0 == rings_parsed)
+                {
+                    ring_type& ring0 = exterior_ring(polygon_buffer);
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ring0, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    interior_rings(polygon_buffer).resize(rings_parsed);
+                    ring_type& ringN = interior_rings(polygon_buffer).back();
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ringN, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                ++rings_parsed;
+            }
+            output = polygon_buffer;
+            ++output;
+        }
+        
+        return true;
+    }
+};
+
+}} // namespace detail::wkb
+#endif // DOXYGEN_NO_IMPL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP

boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_DETAIL_PARSER_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP
+
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+
+#include <boost/geometry/extensions/gis/io/wkb/detail/endian.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/detail/ogc.hpp>
+
+#include <boost/geometry/multi/core/point_type.hpp>
+#include <boost/geometry/multi/core/ring_type.hpp>
+
+#include <boost/geometry/multi/core/interior_rings.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkb
+{
+
+template <typename MultiPoint>
+struct multipoint_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPoint& multipoint, byte_order_type::enum_t order)
+    {
+        typedef typename point_type<MultiPoint>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipoint != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_points(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_points, order))
+        {
+            return false;
+        }
+        
+        // Check that the number of double values in the stream is equal
+        // or greater than the number of expected values in the multipoint
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        
+        size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double)
+                                            + num_points * sizeof(boost::uint8_t)
+                                            + num_points * sizeof(boost::uint32_t);
+        
+        size_type const stream_byte_size = std::distance(it,end);
+        
+        assert(stream_byte_size >= container_byte_size);
+        
+        point_type point_buffer;
+        std::back_insert_iterator<MultiPoint> output(std::back_inserter(multipoint));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_points <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t points_parsed = 0;
+        while (points_parsed < num_points && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t point_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, point_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t point_type_type;
+            if (!geometry_type_parser::parse(it, end, point_type_type, point_byte_order))
+            {
+                return false;
+            }
+            
+            parsing_assigner<point_type, 0, dimension<point_type>::value>::run(it, end, point_buffer, point_byte_order);
+            
+            output = point_buffer;
+            
+            ++output;
+            ++points_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiLinestring>
+struct multilinestring_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiLinestring& multilinestring, byte_order_type::enum_t order)
+    {
+        typedef typename MultiLinestring::value_type linestring_type;
+        typedef typename point_type<MultiLinestring>::type point_type;
+        
+        geometry_type::enum_t type;
+        if (!geometry_type_parser::parse(it, end, type, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multilinestring != type)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_linestrings(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_linestrings, order))
+        {
+            return false;
+        }
+        
+        linestring_type linestring_buffer;
+        std::back_insert_iterator<MultiLinestring> output(std::back_inserter(multilinestring));
+        
+        typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+        assert(num_linestrings <= boost::uint32_t( (std::numeric_limits<size_type>::max)() ) );
+        
+        boost::uint32_t linestrings_parsed = 0;
+        while (linestrings_parsed < num_linestrings && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t linestring_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::linestring != type)
+            {
+                return false;
+            }
+            
+            boost::uint32_t num_points(0);
+            if (!value_parser<boost::uint32_t>::parse(it, end, num_points, linestring_byte_order))
+            {
+                return false;
+            }
+            
+            // Check that the number of double values in the stream is equal
+            // or greater than the number of expected values in the linestring
+            
+            typedef typename std::iterator_traits<Iterator>::difference_type size_type;
+            
+            size_type const container_byte_size = dimension<point_type>::value * num_points * sizeof(double);
+            size_type const stream_byte_size = std::distance(it,end);
+            
+            assert(stream_byte_size >= container_byte_size);
+            
+            return point_container_parser<linestring_type>::parse(it, end, linestring_buffer, linestring_byte_order, num_points);
+            
+            output = linestring_buffer;
+            
+            ++output;
+            ++linestrings_parsed;
+        }
+        return true;
+    }
+};
+
+template <typename MultiPolygon>
+struct multipolygon_parser
+{
+    template <typename Iterator>
+    static bool parse(Iterator& it, Iterator end, MultiPolygon& multipolygon, byte_order_type::enum_t order)
+    {
+        typedef typename MultiPolygon::value_type polygon_type;
+        typedef typename ring_type<MultiPolygon>::type ring_type;
+        
+        geometry_type::enum_t multipolygontype;
+        if (!geometry_type_parser::parse(it, end, multipolygontype, order))
+        {
+            return false;
+        }
+        
+        if (geometry_type::multipolygon != multipolygontype)
+        {
+            return false;
+        }
+        
+        boost::uint32_t num_polygons(0);
+        if (!value_parser<boost::uint32_t>::parse(it, end, num_polygons, order))
+        {
+            return false;
+        }
+        
+        polygon_type polygon_buffer;
+        std::back_insert_iterator<MultiPolygon> output(std::back_inserter(multipolygon));
+        
+        std::size_t polygons_parsed = 0;
+        while(polygons_parsed < num_polygons && it != end)
+        {
+            detail::wkb::byte_order_type::enum_t polygon_byte_order;
+            if (!detail::wkb::byte_order_parser::parse(it, end, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            geometry_type::enum_t type;
+            if (!geometry_type_parser::parse(it, end, type, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            if (geometry_type::polygon != type)
+            {
+                return false;
+            }
+
+            boost::uint32_t num_rings(0);
+            if (geometry_type::polygon != type ||
+                !value_parser<boost::uint32_t>::parse(it, end, num_rings, polygon_byte_order))
+            {
+                return false;
+            }
+            
+            std::size_t rings_parsed = 0;
+            
+            while (rings_parsed < num_rings && it != end)
+            {
+                boost::uint32_t num_points(0);
+                if (!value_parser<boost::uint32_t>::parse(it, end, num_points, polygon_byte_order))
+                {
+                    return false;
+                }
+                
+                if (0 == rings_parsed)
+                {
+                    ring_type& ring0 = exterior_ring(polygon_buffer);
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ring0, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    interior_rings(polygon_buffer).resize(rings_parsed);
+                    ring_type& ringN = interior_rings(polygon_buffer).back();
+                    
+                    if (!point_container_parser<ring_type>::parse(it, end, ringN, polygon_byte_order, num_points))
+                    {
+                        return false;
+                    }
+                }
+                ++rings_parsed;
+            }
+            output = polygon_buffer;
+            ++output;
+        }
+        
+        return true;
+    }
+};
+
+}} // namespace detail::wkb
+#endif // DOXYGEN_NO_IMPL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_DETAIL_PARSER_HPP

boost/geometry/extensions/multi/gis/io/wkb/read_wkb.hpp

@@ +1 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// 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_MULTI_IO_WKB_READ_WKB_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP
+
+#include <iterator>
+
+#include <boost/geometry/extensions/multi/gis/io/wkb/detail/parser.hpp>
+#include <boost/geometry/extensions/gis/io/wkb/read_wkb.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry>
+struct read_wkb<multi_point_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipoint_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_linestring_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multilinestring_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+template <typename Geometry>
+struct read_wkb<multi_polygon_tag, Geometry>
+{
+    template <typename Iterator>
+    static inline bool parse(Iterator& it, Iterator end, Geometry& geometry,
+        detail::wkb::byte_order_type::enum_t order)
+    {
+        return detail::wkb::multipolygon_parser<Geometry>::parse(it, end, geometry, order);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKB_READ_WKB_HPP

boost/geometry/multi/algorithms/equals.hpp

@@ -20 +20 @@
 #include <boost/geometry/multi/geometries/concepts/check.hpp>
 
 #include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/multi/algorithms/num_points.hpp>
 
 
 namespace boost { namespace geometry
@@ -29 +30 @@
 namespace dispatch
 {
 
+template <typename MultiPoint1, typename MultiPoint2, bool Reverse>
+struct equals
+    <
+        MultiPoint1, MultiPoint2,
+        multi_point_tag, multi_point_tag,
+        2,
+        Reverse
+    >
+    : detail::equals::equals_by_collection<detail::equals::num_points_check>
+{};
 
+template <typename MultiLinestring1, typename MultiLinestring2, bool Reverse>
+struct equals
+    <
+        MultiLinestring1, MultiLinestring2,
+        multi_linestring_tag, multi_linestring_tag,
+        2,
+        Reverse
+    >
+    : detail::equals::equals_by_collection<detail::equals::length_check>
+{};
+
 template <typename MultiPolygon1, typename MultiPolygon2, bool Reverse>
 struct equals
     <

libs/geometry/extensions/test/gis/io/Jamfile.v2

@@ +1 @@
+# Boost.Geometry (aka GGL, Generic Geometry Library)
+#
+# Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+# Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+# Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+#
+# 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)
+
+build-project wkb ;
+ No newline at end of file

libs/geometry/extensions/test/gis/io/wkb/Jamfile.v2

@@ +1 @@
+# Boost.Geometry (aka GGL, Generic Geometry Library)
+#
+# Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+# Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+# Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+#
+# 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)
+
+test-suite boost-geometry-extensions-gis-io-wkb
+    :
+    [ run read_wkb.cpp ]
+    ;

libs/geometry/extensions/test/gis/io/wkb/read_wkb.cpp

@@ -10 +10 @@
 #include <iterator>
 #include <string>
 #include <vector>
+#include <iostream>
 
 #include <boost/test/included/test_exec_monitor.hpp>
 #include <boost/test/included/unit_test.hpp>
@@ -17 +18 @@
 #include <boost/cstdint.hpp>
 
 #include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/strategies/strategies.hpp>
 #include <boost/geometry/geometries/geometries.hpp>
 #include <boost/geometry/io/wkt/read.hpp>
 #include <boost/geometry/extensions/gis/io/wkb/read_wkb.hpp>
 #include <boost/geometry/extensions/gis/io/wkb/utility.hpp>
 
+#include <boost/geometry/multi/algorithms/equals.hpp>
+#include <boost/geometry/multi/geometries/multi_geometries.hpp> 
+#include <boost/geometry/multi/io/wkt/wkt.hpp> 
+
+#include <boost/geometry/extensions/multi/gis/io/wkb/read_wkb.hpp>
+
 namespace bg = boost::geometry;
 
 namespace { // anonymous
@@ -37 +45 @@
     std::cout << bg::read_wkb(wkb.begin(), wkb.end(), g_wkb) << std::endl;
 }
 
+template <typename Geometry>
+void test_geometry_parse_failure(std::string const& wkbhex, std::string const& wkt)
+{
+    byte_vector wkb;
+    BOOST_CHECK( bg::hex2wkb(wkbhex, std::back_inserter(wkb)) );
+    Geometry g_wkb;
+    BOOST_CHECK( bg::read_wkb(wkb.begin(), wkb.end(), g_wkb) == false );
+}
+
 template <typename Geometry, bool IsEqual>
 void test_geometry_equals(std::string const& wkbhex, std::string const& wkt)
 {
@@ -47 +64 @@
 
     Geometry g_expected;
     bg::read_wkt(wkt, g_expected);
+    
+    bool eq = bg::equals(g_wkb, g_expected);
+    
+    if(eq != IsEqual)
+    {
+        std::cout << "WKT EXPECTED:"<< bg::wkt(g_expected) << std::endl;
+        std::cout << "WKT ACTUAL:"<< bg::wkt(g_wkb) << std::endl;
+    }
+    
+    BOOST_CHECK( eq == IsEqual );
+}
+
+template <typename Geometry, bool IsEqual>
+void test_geometry_print(std::string const& wkbhex, std::string const& wkt)
+{
+    byte_vector wkb;
+    BOOST_CHECK( bg::hex2wkb(wkbhex, std::back_inserter(wkb)) );
+    Geometry g_wkb;
+    BOOST_CHECK( bg::read_wkb(wkb.begin(), wkb.end(), g_wkb) );
+
+    Geometry g_expected;
+    bg::read_wkt(wkt, g_expected);
+    
+    std::cout << "WKT OUT:"<< bg::wkt(g_wkb) << std::endl;
+    
     BOOST_CHECK( bg::equals(g_wkb, g_expected) == IsEqual );
 }
 
@@ -53 +95 @@
 //template <typename P, bool Result>
 //void test_polygon_wkt(std::string const& wkt)
 //{
-//    typedef bg::model::linestring<P> linestring_type;
-//    typedef bg::model::polygon<linestring_type> polygon_type;
+// typedef bg::model::linestring<P> linestring_type;
+// typedef bg::model::polygon<linestring_type> polygon_type;
 //
-//    polygon_type poly;
-//    bg::read_wkb(wkb, poly);
+// polygon_type poly;
+// bg::read_wkb(wkb, poly);
 //}
 
 } // namespace anonymous
@@ -66 +108 @@
 {
     typedef bg::model::point<double, 2, bg::cs::cartesian> point_type;
     typedef bg::model::linestring<point_type> linestring_type;
+    typedef bg::model::polygon<point_type> polygon_type;
+    
+    typedef bg::model::point<double, 3, bg::cs::cartesian> point_3d_type;
+    typedef bg::model::linestring<point_3d_type> linestring_3d_type;
+    typedef bg::model::polygon<point_3d_type> polygon_3d_type;
 
     //
     // POINT
@@ -104 +151 @@
         "01010000E0E61000005839B4C876BEF33F83C0CAA145B616400000000000002E400000000000C05340",
         "POINT (1.234 5.678)");
 
+//    //// 3D - needs to implement geometry_type handling
+//    
+//    // POINT(1.234 5.678 99)
+//    test_geometry_equals<point_3d_type, true>(
+//        "01e90300005839b4c876bef33f83c0caa145b616400000000000c05840", "POINT Z (1.234 5.678 99)");
+    
+    //
+    // LineString
+    //
+    
+    test_geometry_equals<linestring_type, true>(
+      "0102000000030000005839B4C876BEF33F83C0CAA145B616404F401361C333224062A1D634EF3824409CC420B072482A40EB73B515FB2B3040", 
+      "LINESTRING (1.234 5.678, 9.1011 10.1112, 13.1415 16.1718)");
+    
+    // LINESTRING (1.234 5.678 99, 9.1011 10.1112 99, 13.1415 16.1718 99) - Z coordinate in a two-dimensional linestring
+    // Result is LINESTRING (1.234 5.678, 99 9.1011, 10.1112 99)
+    test_geometry_equals<linestring_type, false>(
+"0102000080030000005839B4C876BEF33F83C0CAA145B616400000000000C058404F401361C333224062A1D634EF3824400000000000C058409CC420B072482A40EB73B515FB2B30400000000000C05840", 
+      "LINESTRING (1.234 5.678, 9.1011 10.1112, 13.1415 16.1718)");
+    
+    //
+    // Polygon
+    //
+    
+    test_geometry_equals<polygon_type, true>(
+"010300000001000000050000000000000000005940000000000000694000000000000069400000000000006940000000000000694000000000000079400000000000005940000000000000794000000000000059400000000000006940",
+    "POLYGON((100 200, 200 200, 200 400, 100 400, 100 200))"
+    );
+    
+    // POLYGON((100 200 99, 200 200 99, 200 400 99, 100 400 99, 100 200 99)) - Z coordinate in a two-dimensional polygon
+    // Result is POLYGON((100 200,99 200,200 99,200 400,99 100))
+    test_geometry_equals<polygon_type, false>(
+"01030000800100000005000000000000000000594000000000000069400000000000C05840000000000000694000000000000069400000000000C05840000000000000694000000000000079400000000000C05840000000000000594000000000000079400000000000C05840000000000000594000000000000069400000000000C05840",
+    "POLYGON((100 200, 200 200, 200 400, 100 400, 100 200))"
+    );
+    
+    test_geometry_equals<polygon_type, true>(
+"0103000000020000000500000000000000008041400000000000002440000000000000244000000000000034400000000000002E40000000000000444000000000008046400000000000804640000000000080414000000000000024400400000000000000000034400000000000003E40000000000080414000000000008041400000000000003E40000000000000344000000000000034400000000000003E40",
+    "POLYGON ((35 10, 10 20, 15 40, 45 45, 35 10),(20 30, 35 35, 30 20, 20 30))"
+    );
+    
+    // POLYGON ((35 10 99, 10 20 99, 15 40 99, 45 45 99, 35 10 99),(20 30 99, 35 35 99, 30 20 99, 20 30 99)) - Z coordinate in a two-dimensional polygon
+    // Result is POLYGON((35 10,99 10,20 99,15 40,99 45),())
+    test_geometry_equals<polygon_type, false>(
+"01030000800200000005000000000000000080414000000000000024400000000000C05840000000000000244000000000000034400000000000C058400000000000002E4000000000000044400000000000C05840000000000080464000000000008046400000000000C05840000000000080414000000000000024400000000000C058400400000000000000000034400000000000003E400000000000C05840000000000080414000000000008041400000000000C058400000000000003E4000000000000034400000000000C0584000000000000034400000000000003E400000000000C05840",
+    "POLYGON ((35 10, 10 20, 15 40, 45 45, 35 10),(20 30, 35 35, 30 20, 20 30))"
+    );
+    
+    
+    //
+    // Multi Geometries
+    //
+    
+    typedef bg::model::multi_point<point_type> multipoint_type;
+    typedef bg::model::multi_linestring<linestring_type> multilinestring_type;
+    typedef bg::model::multi_polygon<polygon_type> multipolygon_type;
+    
+    //
+    // MultiPoint
+    //
+    
+    test_geometry_equals<multipoint_type, true>(
+    "01040000000100000001010000005839b4c876bef33f83c0caa145b61640",
+    "MULTIPOINT (1.234 5.678)"
+    );
+    
+    test_geometry_equals<multipoint_type, true>(
+    "01040000000200000001010000005839B4C876BEF33F83C0CAA145B61640010100000062A1D634EF3824409CC420B072482A40",
+    "MULTIPOINT (1.234 5.678, 10.1112 13.1415)"
+    );
+    
+    //
+    // MultiLineString
+    //
+    
+    test_geometry_equals<multilinestring_type, true>(
+      "0105000000010000000102000000030000005839b4c876bef33f83c0caa145b616404f401361c333224062a1d634ef3824409cc420b072482a40eb73b515fb2b3040", 
+      "MULTILINESTRING((1.234 5.678,9.1011 10.1112,13.1415 16.1718))");
+    test_geometry_equals<multilinestring_type, true>(
+      "0105000000020000000102000000030000005839b4c876bef33f83c0caa145b616404f401361c333224062a1d634ef3824409cc420b072482a40eb73b515fb2b30400102000000020000003333333333333340b81e85eb513835403d0ad7a3703d3740c3f5285c8f423940", 
+      "MULTILINESTRING((1.234 5.678,9.1011 10.1112,13.1415 16.1718),(19.2 21.22,23.24 25.26))");
+
+    
+    //
+    // MultiPolygon
+    //
+    
+    test_geometry_equals<multipolygon_type, true>(
+"010600000001000000010300000001000000050000000000000000005940000000000000694000000000000069400000000000006940000000000000694000000000000079400000000000005940000000000000794000000000000059400000000000006940",
+    "MULTIPOLYGON(((100 200,200 200,200 400,100 400,100 200)))"
+    );
+    
+    test_geometry_equals<multipolygon_type, true>(
+"0106000000010000000103000000020000000500000000000000008041400000000000002440000000000000244000000000000034400000000000002e40000000000000444000000000008046400000000000804640000000000080414000000000000024400400000000000000000034400000000000003e40000000000080414000000000008041400000000000003e40000000000000344000000000000034400000000000003e40",
+    "MULTIPOLYGON(((35 10,10 20,15 40,45 45,35 10),(20 30,35 35,30 20,20 30)))"
+    );
+    
     return 0;
 }

libs/geometry/extensions/test/gis/Jamfile.v2

@@ -8 +8 @@
 # Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 # http://www.boost.org/LICENSE_1_0.txt)
 
+build-project io ;
 build-project latlong ;
 build-project projections ;