libs/geometry/test/iterators/concatenate_iterator.cpp

   1 // Boost.Geometry (aka GGL, Generic Geometry Library)
   2 // Unit Test
   3
   4 // Copyright (c) 2014, Oracle and/or its affiliates.
   5
   6 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
   7
   8 // Licensed under the Boost Software License version 1.0.
   9 // http://www.boost.org/users/license.html
  10
  11 #ifndef BOOST_TEST_MODULE
  12 #define BOOST_TEST_MODULE test_concatenate_iterator
  13 #endif
  14
  15 #include <boost/test/included/unit_test.hpp>
  16
  17 #include <cstddef>
  18 #include <iostream>
  19 #include <sstream>
  20 #include <string>
  21 #include <algorithm>
  22 #include <iterator>
  23
  24 #include <vector>
  25 #include <list>
  26
  27 #include <boost/assign/std/vector.hpp>
  28 #include <boost/assign/std/list.hpp>
  29
  30 #include <boost/core/ignore_unused.hpp>
  31
  32 #include "test_iterator_common.hpp"
  33
  34 #include <boost/geometry/iterators/concatenate_iterator.hpp>
  35
  36 using namespace boost::assign;
  37
  38
  39 struct test_concatenate_iterator
  40 {
  41     template
  42     <
  43         typename ConcatenateIterator,
  44         typename ConstConcatenateIterator,
  45         typename Container
  46     >
  47     static inline
  48     void test_using_max_element(ConcatenateIterator first,
  49                                 ConcatenateIterator beyond,
  50                                 ConstConcatenateIterator const_first,
  51                                 ConstConcatenateIterator const_beyond,
  52                                 Container const& c,
  53                                 std::size_t other_size,
  54                                 bool second_container)
  55     {
  56         typedef typename std::iterator_traits
  57             <
  58                 ConcatenateIterator
  59             >::value_type value_type;
  60
  61         if ( c.size() == 0 )
  62         {
  63             return;
  64         }
  65
  66         ConcatenateIterator c_first = first;
  67         if ( second_container )
  68         {
  69             std::size_t counter(0);
  70             while ( counter != other_size )
  71             {
  72                 ++counter;
  73                 c_first++;
  74             }
  75         }
  76
  77         ConcatenateIterator it_max = std::max_element(first, beyond);
  78         ConstConcatenateIterator const_it_max =
  79             std::max_element(const_first, const_beyond);
  80
  81         BOOST_CHECK( it_max == const_it_max );
  82         BOOST_CHECK( *it_max == *const_it_max );
  83
  84         value_type old_value = *c_first;
  85         value_type new_value = *it_max + 1;
  86
  87         *c_first = *it_max + 1;
  88         BOOST_CHECK( *c.begin() == new_value );
  89
  90 #ifdef BOOST_GEOMETRY_TEST_DEBUG
  91         std::cout << std::endl;
  92         std::cout << "modified element of ";
  93         std::cout << (second_container ? "2nd" : "1st");
  94         std::cout << " container:" << std::endl;
  95         print_container(std::cout, c.begin(), c.end(),
  96                         (second_container ? "second  :" : "first  :"))
  97             << std::endl;
  98         print_container(std::cout, first, beyond, "combined:") << std::endl;
  99 #endif
 100
 101         *c_first = old_value;
 102         BOOST_CHECK( *c.begin() == old_value );
 103     }
 104
 105
 106     template <typename Container1, typename Container2>
 107     static inline void apply(Container1& c1, Container2& c2,
 108                              std::string const& case_id,
 109                              std::string const& containers_id)
 110     {
 111         boost::ignore_unused(case_id, containers_id);
 112
 113 #ifdef BOOST_GEOMETRY_TEST_DEBUG
 114         std::stringstream sstream;
 115         sstream << case_id << " [" << containers_id << "]";
 116
 117         std::cout << "case id: " << sstream.str() << std::endl;
 118 #endif
 119         typedef typename Container1::const_iterator const_iterator1;
 120         typedef typename Container2::const_iterator const_iterator2;
 121         typedef typename Container1::iterator iterator1;
 122         typedef typename Container2::iterator iterator2;
 123
 124         typedef boost::geometry::concatenate_iterator
 125             <
 126                 const_iterator1, const_iterator2,
 127                 typename Container1::value_type const
 128             > const_concat_iterator;
 129
 130         typedef boost::geometry::concatenate_iterator
 131             <
 132                 iterator1, iterator2, typename Container1::value_type
 133             > concat_iterator;
 134
 135         typedef typename std::iterator_traits
 136             <
 137                 concat_iterator
 138             >::value_type value_type;
 139
 140         // test constructors/assignment operators
 141         concat_iterator begin(c1.begin(), c1.end(), c2.begin(), c2.begin());
 142         concat_iterator end(c1.end(), c2.begin(), c2.end());
 143         const_concat_iterator const_begin(begin);
 144         const_concat_iterator const_end(end);
 145         const_begin = begin;
 146         const_end = end;
 147
 148         concat_iterator begin2(c1.end(), c1.end(), c2.begin(), c2.begin());
 149         const_concat_iterator const_begin2(c1.end(), c1.end(),
 150                                            c2.begin(), c2.begin());
 151
 152         BOOST_CHECK( c1.empty() || *begin == *c1.begin() );
 153         BOOST_CHECK( c1.empty() || *const_begin == *c1.begin() );
 154
 155         BOOST_CHECK( c2.empty() || *begin2 == *c2.begin() );
 156         BOOST_CHECK( c2.empty() || *const_begin2 == *c2.begin() );
 157
 158
 159         // test copying, dereferencing and element equality
 160         std::vector<value_type> combined;
 161         std::copy(c1.begin(), c1.end(), std::back_inserter(combined));
 162         std::copy(c2.begin(), c2.end(), std::back_inserter(combined));
 163         test_equality(begin, end, combined);
 164
 165         combined.clear();
 166         std::copy(begin, end, std::back_inserter(combined));
 167         test_equality(begin, end, combined);
 168         test_equality(const_begin, const_end, combined);
 169
 170         combined.clear();
 171         std::copy(const_begin, const_end, std::back_inserter(combined));
 172         test_equality(begin, end, combined);
 173         test_equality(const_begin, const_end, combined);
 174
 175         // test sizes (and std::distance)
 176         test_size(begin, end, combined);
 177         test_size(const_begin, const_end, combined);
 178
 179
 180 #ifdef BOOST_GEOMETRY_TEST_DEBUG
 181         print_container(std::cout, c1.begin(), c1.end(), "first   :")
 182             << std::endl;
 183         print_container(std::cout, c2.begin(), c2.end(), "second  :")
 184             << std::endl;
 185         print_container(std::cout, begin, end,           "combined:")
 186             << std::endl;
 187
 188         if ( begin != end )
 189         {
 190             std::cout << "min element: "
 191                       << *std::min_element(begin, end)
 192                       << std::endl;
 193             std::cout << "max element: "
 194                       << *std::max_element(const_begin, const_end)
 195                       << std::endl;
 196         }
 197 #endif
 198
 199         // perform reversals (std::reverse)
 200         test_using_reverse(begin, end, combined);
 201
 202         // test std::max_element, dereferencing and value assigment
 203         test_using_max_element(begin, end, const_begin, const_end,
 204                                c1, c2.size(), false);
 205         test_using_max_element(begin, end, const_begin, const_end,
 206                                c2, c1.size(), true);
 207
 208         // test std::count_if / std::remove_if
 209         test_using_remove_if(begin, end, combined);
 210
 211 #ifdef BOOST_GEOMETRY_TEST_DEBUG
 212         std::cout << "====================" << std::endl << std::endl;
 213 #endif
 214     }
 215 };
 216
 217
 218 template <typename Container1, typename Container2>
 219 inline void test_concatenation_of_containers(Container1& c1, Container2& c2,
 220                                              std::string const& containers_id)
 221 {
 222 #ifdef BOOST_GEOMETRY_TEST_DEBUG
 223     std::cout << std::endl << std::endl;
 224     std::cout << "************************************" << std::endl
 225               << " TESTING CONTAINERS COMBINATION: "
 226               << containers_id << std::endl
 227               << "************************************" << std::endl
 228               << std::endl;
 229 #endif
 230
 231     c1.clear();
 232     c2.clear();
 233     test_concatenate_iterator::apply(c1, c2, "empty_both", containers_id);
 234
 235     c2 += 10,11,12,13,14,15,16,17,18,19,20;
 236     test_concatenate_iterator::apply(c1, c2, "empty_first", containers_id);
 237
 238     c2.clear();
 239     c1 += 0,1,2,3,4,5,6;
 240     test_concatenate_iterator::apply(c1, c2, "empty_second", containers_id);
 241
 242     c1.clear();
 243     c2.clear();
 244     c1 += 0,1,2,3,4,5,6;
 245     c2 += 10,11,12,13,14,15,16,17,18,19,20;
 246     test_concatenate_iterator::apply(c1, c2, "non_empty", containers_id);
 247 }
 248
 249
 250 BOOST_AUTO_TEST_CASE( test_concatenate_iterator_all )
 251 {
 252     std::vector<int> v, vv;
 253     std::list<int> l, ll;
 254
 255     test_concatenation_of_containers(v, vv, "VV");
 256     test_concatenation_of_containers(v, l, "VL");
 257     test_concatenation_of_containers(l, v, "LV");
 258     test_concatenation_of_containers(l, ll, "LL");
 259 }