cgal/STL_Extension/test/STL_Extension/test_Nested_iterator.cpp

#include <iostream>
#include <list>
#include <vector>

#include <CGAL/Nested_iterator.h>

template<class T>
const T& dummy(const T& t) {
  return t;
}

int main()
{
  std::vector< std::vector<int> > v;

  std::vector<int> empty;
  std::vector<int> v1;
  std::vector<int> v2;
  std::vector<int> v3;
  std::vector<int> v4;


  int n = 5;
  for (int i = 0; i < n; i++) {
    v1.push_back(i);
    v2.push_back(i + n * 10);
    v3.push_back(i + n * 100);
    v4.push_back(i + n * 1000);
  }

  v.push_back(empty);
  v.push_back(empty);
  v.push_back(v1);
  v.push_back(v2);
  v.push_back(empty);
  v.push_back(v3);
  v.push_back(empty);
  v.push_back(v4);
  v.push_back(empty);
  v.push_back(empty);
  v.push_back(empty);

  {
    for (unsigned int i = 0; i < v.size(); i++) {
      std::cout << "List " << (i+1) << ": ";
      for (unsigned int j = 0; j < v[i].size(); j++) {
        std::cout << " " << v[i][j];
      }
      std::cout << std::endl;
    }
    std::cout << std::endl;
  }

  typedef std::vector< std::vector<int> >::iterator b_iterator;

  typedef CGAL::Nested_iterator<b_iterator>  n_iterator;

  //------------------------------------------------------------------
  {
    std::cout << "================================================"
              << std::endl << std::endl;
    {
      std::cout << "testing constructors..." << std::flush;
      {
        n_iterator ni;
        n_iterator ni_begin(v.end(), v.begin());
        n_iterator ni_end(v.end(), v.end());

        dummy(ni);
        dummy(ni_begin);
        dummy(ni_end);
      }

      std::vector< std::vector<int> > v1;
      {
        n_iterator ni;
        n_iterator ni_begin(v1.end(), v1.begin());
        n_iterator ni_end(v1.end(), v1.end());

        dummy(ni);
        dummy(ni_begin);
        dummy(ni_end);
      }

      v1.push_back(empty);
      v1.push_back(empty);
      {
        n_iterator ni;
        n_iterator ni_begin(v1.end(), v1.begin());
        n_iterator ni_end(v1.end(), v1.end());

        dummy(ni);
        dummy(ni_begin);
        dummy(ni_end);
      }

      std::cout << " yes" << std::endl;
    }
    {
      std::cout << "testing copy constructor..." << std::flush;
      {
        n_iterator ni_begin(v.end(), v.begin());
        n_iterator ni(ni_begin);

        dummy(ni);
        dummy(ni_begin);
      }

      std::vector< std::vector<int> > v1;
      {
        n_iterator ni_begin(v1.end(), v1.begin());
        n_iterator ni(ni_begin);

        dummy(ni);
        dummy(ni_begin);
      }

      v1.push_back(empty);
      v1.push_back(empty);
      {
        n_iterator ni_begin(v1.end(), v1.begin());
        n_iterator ni(ni_begin);

        dummy(ni);
        dummy(ni_begin);
      }

      std::cout << " yes" << std::endl;
    }
    {
      std::cout << "testing assignment operator..." << std::flush;
      {
        n_iterator ni_begin(v.end(), v.begin());
        n_iterator ni;
        ni = ni_begin;

        dummy(ni);
        dummy(ni_begin);
      }
      std::vector< std::vector<int> > v1;
      {
        n_iterator ni_begin(v1.end(), v1.begin());
        n_iterator ni;
        ni = ni_begin;

        dummy(ni);
        dummy(ni_begin);
      }

      v1.push_back(empty);
      v1.push_back(empty);
      {
        n_iterator ni_begin(v1.end(), v1.begin());
        n_iterator ni;
        ni = ni_begin;

        dummy(ni);
        dummy(ni_begin);
      }
      std::cout << " yes" << std::endl;
    }
  }

  //------------------------------------------------------------------
  {
    std::cout << "================================================"
              << std::endl << std::endl;
    n_iterator ni_begin(v.end(), v.begin());
    n_iterator ni_end(v.end(), v.end());

    std::cout << "Nested iterator:" << std::endl;
    n_iterator ni_it;
    for (ni_it = ni_begin; ni_it != ni_end; ++ni_it) {
      std::cout << " " << (*ni_it);
    }
    std::cout << std::endl << std::endl;

    std::cout << "Nested iterator in reverse order:" << std::endl;
    for (ni_it = --ni_end; ni_it != ni_begin; --ni_it) {
      std::cout << " " << (*ni_it);
    }
    std::cout << " " << (*ni_it);
    std::cout << std::endl << std::endl;
  }
  //------------------------------------------------------------------
  {
    std::cout << "================================================"
              << std::endl << std::endl;
    v.clear();
    v.push_back(empty);
    v.push_back(empty);
    v.push_back(empty);
    v.push_back(empty);


    {
      for (unsigned int i = 0; i < v.size(); i++) {
        std::cout << "List " << (i+1) << ": ";
        for (unsigned int j = 0; j < v[i].size(); j++) {
          std::cout << " " << v[i][j];
        }
        std::cout << std::endl;
      }
      std::cout << std::endl;
    }

    n_iterator ni_begin(v.end(), v.begin());
    n_iterator ni_end(v.end(), v.end());

    std::cout << "Nested iterator:" << std::endl;
    n_iterator ni_it;
    for (ni_it = ni_begin; ni_it != ni_end; ++ni_it) {
      std::cout << " " << (*ni_it);
    }
    std::cout << std::endl << std::endl;


    std::cout << "Nested iterator in reverse order:" << std::endl;
    if ( ni_begin != ni_end ) {
      for (ni_it = --ni_end; ni_it != ni_begin; --ni_it) {
        std::cout << " " << (*ni_it);
      }
      std::cout << " " << (*ni_it);
    }
    std::cout << std::endl << std::endl;
  }


  //------------------------------------------------------------------
  {
    std::cout << "================================================"
              << std::endl << std::endl;
    v.clear();
    v1.clear();

    v1.push_back(1);

    v.push_back(empty);
    v.push_back(v1);
    v.push_back(empty);
    v.push_back(empty);


    {
      for (unsigned int i = 0; i < v.size(); i++) {
        std::cout << "List " << (i+1) << ": ";
        for (unsigned int j = 0; j < v[i].size(); j++) {
          std::cout << " " << v[i][j];
        }
        std::cout << std::endl;
      }
      std::cout << std::endl;
    }

    n_iterator ni_begin(v.end(), v.begin());
    n_iterator ni_end(v.end(), v.end());

    std::cout << "Nested iterator:" << std::endl;
    n_iterator ni_it;
    for (ni_it = ni_begin; ni_it != ni_end; ++ni_it) {
      std::cout << " " << (*ni_it);
    }
    std::cout << std::endl << std::endl;


    std::cout << "Nested iterator in reverse order:" << std::endl;
    if ( ni_begin != ni_end ) {
      for (ni_it = --ni_end; ni_it != ni_begin; --ni_it) {
        std::cout << " " << (*ni_it);
      }
      std::cout << " " << (*ni_it);
    }
    std::cout << std::endl << std::endl;
  }

  //------------------------------------------------------------------
  {
    std::cout << "================================================"
              << std::endl << std::endl;
    v.clear();
    v1.clear();

    v1.push_back(1);
    v1.push_back(2);

    v.push_back(v1);
    v.push_back(empty);
    v.push_back(empty);
    v.push_back(empty);
    v.push_back(v1);


    {
      for (unsigned int i = 0; i < v.size(); i++) {
        std::cout << "List " << (i+1) << ": ";
        for (unsigned int j = 0; j < v[i].size(); j++) {
          std::cout << " " << v[i][j];
        }
        std::cout << std::endl;
      }
      std::cout << std::endl;
    }

    n_iterator ni_begin(v.end(), v.begin());
    n_iterator ni_end(v.end(), v.end());

    std::cout << "Nested iterator:" << std::endl;
    for (n_iterator ni_it = ni_begin; ni_it != ni_end; ++ni_it) {
      std::cout << " " << (*ni_it);
    }
    std::cout << std::endl << std::endl;


    std::cout << "Nested iterator in reverse order:" << std::endl;
    if ( ni_begin != ni_end ) {
      n_iterator ni_it;
      for (ni_it = --ni_end; ni_it != ni_begin; --ni_it) {
        std::cout << " " << (*ni_it);
      }
      std::cout << " " << (*ni_it);
    }
    std::cout << std::endl << std::endl;
  }
}