{

std::vector<int> v = {1, 2, 3};

using iterator = bg::closing_iterator<std::vector<int>>;

using const_iterator = bg::closing_iterator<std::vector<int> const>;

iterator it, it2(v);

const_iterator cit, cit2(v);

BOOST_CHECK((std::is_same<decltype(*it2), const int&>::value));

BOOST_CHECK((std::is_same<decltype(*cit2), const int&>::value));

it = it2;

cit = cit2;

BOOST_CHECK_EQUAL(*it, 1);

BOOST_CHECK_EQUAL(*cit, 1);

cit = ++it;

BOOST_CHECK_EQUAL(*it, 2);

BOOST_CHECK_EQUAL(*cit, 2);

// This is ok because both of these iterators are in fact const iterators

it = ++cit;

BOOST_CHECK_EQUAL(*it, 3);

BOOST_CHECK_EQUAL(*cit, 3);

// Check compilations, it is (since Oct 2010) random access

it--;

--it;

it += 2;

it -= 2;

{

std::vector<int> v;

typedef bg::closing_iterator

<

std::vector<int> const

> closing_iterator;

closing_iterator it(v);

closing_iterator end(v, true);

BOOST_CHECK(it == end);

{

std::vector<int> v = {1, 2, 3};

std::vector<int> closed_v = { 1, 2, 3, 1 };

typedef bg::closing_iterator

<

std::vector<int> const

> closing_iterator;

closing_iterator it(v);

closing_iterator end(v, true);

BOOST_CHECK(std::equal(it, end, closed_v.begin(), closed_v.end()));

{

std::vector<int> v = {-1, -2, -3};

std::vector<int> closed_v = { 1, 2, 3, 1 };

typedef boost::transformed_range

<

std::negate<int>,

std::vector<int>

> transformed_range;

typedef bg::closing_iterator

<

transformed_range const

> closing_iterator;

transformed_range v2 = v | boost::adaptors::transformed(std::negate<int>());

closing_iterator it(v2);

closing_iterator end(v2, true);

BOOST_CHECK(std::equal(it, end, closed_v.begin(), closed_v.end()));

{

bg::model::ring<P> geometry = { {1, 1}, {1, 4}, {4, 4}, {4, 1} };

bg::model::ring<P> closed = { {1, 1}, {1, 4}, {4, 4}, {4, 1}, {1, 1} };

using closing_iterator = bg::closing_iterator<bg::model::ring<P> const>;

auto pred = [](P const& p1, P const& p2)

{

return bg::get<0>(p1) == bg::get<0>(p2) && bg::get<1>(p1) == bg::get<1>(p2);

};

// 1. Test normal behaviour

{

closing_iterator it(geometry);

closing_iterator end(geometry, true);

BOOST_CHECK((std::equal(it, end, closed.begin(), closed.end(), pred)));

}

// 2: check copy behaviour

{

bg::model::ring<P> copy;

std::copy(closing_iterator(geometry), closing_iterator(geometry, true),

std::back_inserter(copy));

BOOST_CHECK((std::equal(copy.begin(), copy.end(), closed.begin(), closed.end(), pred)));

}

{

test_concept();

test_empty_non_geometry();

test_non_geometry();

test_transformed_non_geometry();

test_geometry<bg::model::d2::point_xy<double>>();

return 0;