#include <boost/geometry.hpp>
#include <boost/range/iterator_range_core.hpp>

#include <vector>

struct point {
    double x;
    double y;
};

using ring = std::vector<point>;
using polygon = std::vector<ring>;

namespace boost {
namespace geometry {
namespace traits {

template <>
struct tag<point>
{
    using type = point_tag;
};

template <>
struct coordinate_type<point>
{
    using type = double;
};

template <>
struct coordinate_system<point>
{
    using type = boost::geometry::cs::cartesian;
};

template <>
struct dimension<point>
    : boost::mpl::int_<2>
{
};

template <>
struct access<point, 0>
{
    static double get(point const& p)
    {
        return p.x;
    }

    static void set(point& p, double x)
    {
        p.x = x;
    }
};

template <>
struct access<point, 1>
{
    static double get(point const& p)
    {
        return p.y;
    }

    static void set(point& p, double y)
    {
        p.y = y;
    }
};

template <>
struct tag<ring>
{
    using type = ring_tag;
};

template <>
struct tag<polygon>
{
    using type = polygon_tag;
};

template <>
struct ring_mutable_type<polygon>
{
    using type = ring&;
};

template <>
struct ring_const_type<polygon>
{
    using type = ring const&;
};

template <>
struct interior_mutable_type<polygon>
{
    using type = boost::iterator_range<typename polygon::iterator>;
};

template <>
struct interior_const_type<polygon>
{
    using type = boost::iterator_range<typename polygon::const_iterator>;
};

template <>
struct exterior_ring<polygon>
{
    static auto& get(polygon& p)
    {
        return p.at(0);
    }

    static auto const& get(polygon const& p)
    {
        return p.at(0);
    }
};

template <>
struct interior_rings<polygon >
{
    static auto get(polygon& p)
    {
        return boost::make_iterator_range(p.begin() + 1, p.end());
    }

    static auto get(polygon const& p)
    {
        return boost::make_iterator_range(p.begin() + 1, p.end());
    }
};

}
}
}

void testBoost() {
    polygon a;
    polygon b;
    std::vector<polygon> result;
    boost::geometry::intersection(a, b, result);
}