Renamed remotely

[SVN r38365]

doc/GNUmakefile

@@ -0,0 +1,232 @@
+# GNUmakefile for postprocessing PDF files
+#
+# © 2000 IBM Corporation.
+# Licensed under the GNU GPL.
+
+########################################################################
+# Make sure that the following macros are correct for your setup
+########################################################################
+# ... System utilities
+RMRF	= /bin/rm -rf
+MV	= /bin/mv
+EGREP	= /bin/egrep
+ECHO	= /bin/echo
+PERL	= /usr/bin/perl
+PYTHON	= python
+CAT	= /bin/cat
+TOUCH 	= /bin/touch
+ZIP	= /usr/bin/zip
+
+# ... TeX & postprocessors
+PPOWER4	      = ppower4
+PDFLATEX      = pdflatex
+METAPOST      = mpost
+FIG2DEV	      = fig2dev
+BIBTEX	      = bibtex
+FOLIAGECUTTER = foliageCutter --verbose
+RST2LATEX	  = rst2latex
+RST2HTML	  = rst2html
+
+TEX = latex
+export TEX
+########################################################################
+# End of user servicable parts; don't fiddle with the remainder of this
+# makefile unless you know what you do.
+#
+# You have been warned ;=)
+########################################################################
+
+# ... Variables
+TEXFILES = $(strip $(wildcard *.tex))
+RSTFILES = $(strip $(wildcard *.rst))
+-include GNUmakefile.local
+TEXSTEMS = $(strip $(patsubst %.tex,%,${TEXFILES}))
+RSTSTEMS = $(strip $(patsubst %.rst,%,${RSTFILES}))
+CUTFOILS = $(strip $(patsubst %,%---toc.tex,${TEXSTEMS}))
+PDFFILES = $(strip $(patsubst %.tex,%.pdf,${TEXFILES}))
+PRINTS = $(patsubst %.pdf,%-print.pdf,${PDFFILES})
+PRINTZIP = prints.zip
+SLIDEZIP = slides.zip
+
+# ... Depend
+DEPENDFILES = .depend
+GENFILE	    = .generated
+
+# ... List of extensions and files generated
+texcrap = *.mpx *.log *.aux *.blg *-print.brf *-print.tex *.out
+
+mpxcrap = mpxerr.tex mpxerr.pdf
+
+generated = *.out *.[0-9] *.[0-9][0-9] *.bbl *.brf \
+	    *.mp *.mmp *.pdf *.ps TMP-*.pdf *.ftoc\
+	    ${PRINTZIP} ${SLIDEZIP} ${GENFILE} ${DEPENDFILES} \
+	    ${texcrap} ${mpxcrap} ${CUTFOILS} $(strip $(wildcard *---*.tex))
+
+
+# ... canned command to run PDFLaTeX
+define run-pdflatex
+@${ECHO} ""
+@${ECHO} "---- Running PDFLaTeX on $<" && ${PDFLATEX} $<
+@${ECHO} "---- Running PDFLaTeX on $< again" && ${PDFLATEX} $<
+-@(${EGREP} -qi 'Rerun to get' $*.log && \
+		${ECHO} "---- Rerunning PDFLaTeX on $* to get cross-refs right" && \
+		${PDFLATEX} $<) || \
+		${ECHO} "---- No cross-refs correcting PDFLaTeX rerun required for $*"
+-@(${EGREP} -qi $*.ftoc $*.log && \
+		${ECHO} "---- Rerunning PDFLaTeX on $* for FTOC" && \
+		${PDFLATEX} $<) || \
+		${ECHO} "---- No FTOC PDFLaTeX run required for $*"
+-@(${EGREP} -qi 'Warning: Citation' $*.log && \
+		${ECHO} "---- Running BIBTeX on $*" && \
+		${BIBTEX} $* && \
+		${ECHO} "---- Running PDFLaTeX on $<" && \
+		${PDFLATEX} $<) || \
+		${ECHO} "---- No BIBTeX run required for $*"
+-@(${EGREP} -qi 'Warning: .+undefined references' $*.log && \
+		${ECHO} "---- Running PDFLaTeX on $<" && \
+		${PDFLATEX} $<) || \
+		${ECHO} "---- No further PDFLaTex run required for $<"
+@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
+@${RMRF} ${texcrap}
+endef
+
+# ... canned command to run PDFLaTeX for printable versions
+define run-pdflatex-for-print
+@${ECHO} ""
+@${ECHO} "---- Running PDFLaTeX on $*-print.tex" && ${PDFLATEX} $*-print.tex
+@${ECHO} "---- Running PDFLaTeX on $< again" && ${PDFLATEX} $<
+-@(${EGREP} -qi 'Warning: Citation' $*-print.log && \
+		${ECHO} "---- Running BIBTeX on $*-print" && \
+		${BIBTEX} $*-print && \
+		${ECHO} "---- Running PDFLaTeX on $*-print.tex" && \
+		${PDFLATEX} $*-print.tex) || \
+		${ECHO} "---- No BIBTeX run required for $*"
+-@(${EGREP} -qi 'Warning: .+undefined references' $*-print.log && \
+		${ECHO} "---- Running PDFLaTeX on $*-print" && \
+		${PDFLATEX} $*-print.tex) || \
+		${ECHO} "---- No further PDFLaTex run required for $*-print"
+@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
+@${RMRF} ${texcrap}
+endef
+
+# DWA begin modifications
+# ... Rule: How to generate TeX from ReST
+%.tex: %.txt
+	@${ECHO} "---- Running rst2latex on $<"
+	${RST2LATEX} $< $@
+	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
+
+# ... Rule: How to generate TeX from ReST
+%.tex: %.rst
+	@${ECHO} "---- Running rst2latex on $<"
+	${RST2LATEX} $< $@
+	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
+
+# ... Rule: How to generate HTML from ReST
+%.html: %.txt
+	@${ECHO} "---- Running rst2html on $<"
+	${RST2HTML} $< $@
+	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
+
+# ... Rule: How to generate HTML from ReST
+%.html: %.rst
+	@${ECHO} "---- Running rst2html on $<"
+	${RST2HTML} $< $@
+	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
+# DWA end modifications
+
+# ... Rule: How to generate PDF from TeX
+%.pdf: %.tex
+	$(run-pdflatex)
+	@${MV} $@ TMP-$@
+	@${ECHO} "---- Running PPower4 on $*"
+	${PPOWER4} -v TMP-$@ $@
+	@${RMRF} TMP-$@
+	@${ECHO} "Postprocessed: $*.pdf {$*.pdf}" >> ${GENFILE}
+
+# ... Rule: How to generate printable PDF from TeX
+%-print.pdf: %.tex
+	${PERL} -pe 's/^\\documentclass\[(.*?)\]/\\documentclass\[$$1,prints\]/;' < $< > $*-print.tex
+	$(run-pdflatex-for-print)
+	@${ECHO} "Generated:     $*-print.pdf {$*.pdf}" >> ${GENFILE}
+
+# ... Rule: How to generate cut foils from TeX master
+%---toc.tex: %.tex
+	${FOLIAGECUTTER} --prefix=$* $<
+
+# ... Rule: How to generate MetaPost from FIG
+%.mp: %.fig
+	@${ECHO} "---- Running Fig2Dev (mp) on $<"
+	${FIG2DEV} -L mp $< $@
+	@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
+
+# ... Rule: How to generate MultiMetaPost from FIG
+%.mmp: %.fig
+	@${ECHO} "---- Running Fig2Dev (mmp) on $<"
+	${FIG2DEV} -L mmp $< $@
+	@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
+
+# ... Rule: How to generate includable PS from FIG via MetaPost
+%.mps: %.fig
+	@${ECHO} "---- Running Fig2Dev (mps) on $<"
+	${FIG2DEV} -L mp $< $*.mps.mp
+	@${RMRF} $*.mps.[0-9]
+	${METAPOST} $*.mps.mp
+	@${MV} $*.mps.0 $@
+	@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
+
+# ... Rule: How to generate includable PS files from MultiMetaPost
+%.0: %.mmp
+	@${ECHO} "---- Running MetaPost on $<"
+	@${RMRF} $*.[0-9] $*.[0-9][0-9]
+	${METAPOST} $<
+	@${ECHO} "Generated:     $*.0{...} {$<}" >> ${GENFILE}
+
+cleanup-crap:
+	@${RMRF} ${mpxcrap}
+
+# ... Target: all
+all: cleanup-crap ${DEPENDFILES} ${PDFFILES} ${PRINTS} ${PRINTZIP} ${SLIDEZIP}
+	@${ECHO} ""
+	@${TOUCH} ${GENFILE}
+	@${CAT} ${GENFILE}
+	@${RMRF} ${GENFILE}
+
+# ... Target: ZIP files
+zip zips: ${PRINTZIP} ${SLIDEZIP}
+
+# ... Target: ZIP file containing printable versions of slides
+${PRINTZIP}: .depend ${PDFFILES}
+	@${RMRF} ${PRINTZIP}
+	${ZIP} -r ${PRINTZIP} ${PRINTS}
+	@${ECHO} "Generated:     ${PRINTZIP}" >> ${GENFILE}
+
+# ... Target: ZIP file containing screen versions of slides
+ ${SLIDEZIP}: .depend ${PDFFILES}
+	@${RMRF} ${SLIDEZIP}
+	${ZIP} -r ${SLIDEZIP} ${PDFFILES}
+	@${ECHO} "Generated:     ${SLIDEZIP}" >> ${GENFILE}
+
+# ... Target: clean up
+clean:
+	${RMRF} ${generated}
+
+# ... Target: create dependencies
+depend: .depend
+
+# ... Target: dependency file (parse TEXFILES for multiinclude and includegraphics)
+# .depend: GNUmakefile ${TEXFILES}
+# 	${RMRF} $@
+# 	@for t in ${TEXSTEMS} ; do \
+# 		${ECHO} "Scanning $$t.tex"; \
+# 		${PERL} -e 'my $$target = shift @ARGV;' -e 'while (<>) { /\\multiinclude(\[.*?\])?{(.*?)}/ && print "$$target: $$2.0\n";}' $$t.pdf < $$t.tex >> $@; \
+# 		${PERL} -e 'my $$target = shift @ARGV;' -e 'while (<>) { /\\includegraphics(\[.*?\])?{(.*?)\.(.*?)}/ && print "$$target: $$2.$$3\n";}' $$t.pdf < $$t.tex >> $@; \
+# 	done
+
+.depend: GNUmakefile ${RSTFILES}
+	${RMRF} $@
+	${PYTHON} scanrst.py ${RSTFILES} > $@
+
+# ... include dependency files
+# -include .depend
+-include .depend

include/boost/iterator/zip_iterator.hpp

@@ -1,353 +0,0 @@
-// (C) Copyright David Abrahams and Thomas Becker 2000. Permission to
-// copy, use, modify, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. This software
-// is provided "as is" without express or implied warranty, and with
-// no claim as to its suitability for any purpose.
-//
-// Compilers Tested:
-// =================
-// Metrowerks Codewarrior Pro 7.2, 8.3
-// gcc 2.95.3
-// gcc 3.2
-// Microsoft VC 6sp5 (test fails due to some compiler bug)
-// Microsoft VC 7 (works)
-// Microsoft VC 7.1
-// Intel 5
-// Intel 6
-// Intel 7.1
-// Intel 8
-// Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
-
-#ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
-# define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
-
-#include <stddef.h>
-#include <boost/iterator.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/iterator/detail/minimum_category.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/lambda.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/mpl/front.hpp>
-#include <boost/mpl/fold.hpp>
-#include <boost/mpl/transform.hpp>
-
-#include <boost/spirit/fusion/algorithm/transform.hpp>
-#include <boost/spirit/fusion/algorithm/for_each.hpp>
-#include <boost/spirit/fusion/algorithm/fold.hpp>
-#include <boost/spirit/fusion/sequence/generate.hpp>
-#include <boost/spirit/fusion/sequence/begin.hpp>
-#include <boost/spirit/fusion/algorithm/push_front.hpp>
-#include <boost/spirit/fusion/sequence/equal_to.hpp>
-
-namespace boost {
-
-  // Zip iterator forward declaration for zip_iterator_base
-  template<typename IteratorTuple>
-  class zip_iterator;
-
-  namespace detail
-  {
-
-    // Functors to be used with tuple algorithms
-    //
-    template<typename DiffType>
-    class advance_iterator
-    {
-    public:
-      advance_iterator(DiffType step) : m_step(step) {}
-      
-      template<typename Iterator>
-      void operator()(Iterator& it) const
-      { it += m_step; }
-
-    private:
-      DiffType m_step;
-    };
-    //
-    struct increment_iterator
-    {
-      template<typename Iterator>
-      void operator()(Iterator& it) const
-      { ++it; }
-    };
-    //
-    struct decrement_iterator
-    {
-      template<typename Iterator>
-      void operator()(Iterator& it) const
-      { --it; }
-    };
-    //
-    struct dereference_iterator
-    {
-      template<typename Iterator>
-      struct apply : iterator_reference<Iterator>
-      {};
-
-      template<typename Iterator>
-      typename apply<Iterator>::type
-      operator()(Iterator const& it) const
-      { return *it; }
-    };
-
-    struct dereference
-    {
-        template <class Iterator>
-        struct apply
-          : boost::iterator_reference<Iterator>
-        {};
-
-        template <class Iterator>
-        typename apply<Iterator>::type operator()(Iterator const& x) const
-        {
-            return *x;
-        }
-    };
-    
-    // Metafunction to obtain the type of the tuple whose element types
-    // are the reference types of an iterator tuple.
-    //
-    template<typename IteratorTuple>
-    struct tuple_of_references
-      : mpl::transform<IteratorTuple, dereference::apply<mpl::_1> >
-    {};
-    
-    // Metafunction to obtain the minimal traversal tag in a tuple
-    // of iterators.
-    //
-    template<typename IteratorTuple>
-    struct minimum_traversal_category_in_iterator_tuple
-      : mpl::fold<
-            typename mpl::transform<
-                IteratorTuple, iterator_traversal<>
-            >::type
-          , random_access_traversal_tag
-          , minimum_category<>
-        >
-    {};
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-      template <>
-      struct minimum_traversal_category_in_iterator_tuple<int>
-      {
-          typedef int type;
-      };
-#endif
-      
-      // We need to call tuple_meta_accumulate with mpl::and_ as the
-      // accumulating functor. To this end, we need to wrap it into
-      // a struct that has exactly two arguments (that is, template
-      // parameters) and not five, like mpl::and_ does.
-      //
-      template<typename Arg1, typename Arg2>
-      struct and_with_two_args
-        : mpl::and_<Arg1, Arg2>
-      {
-      };
-    
-# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
-  // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
-  // out well.  In this case I think it's an MPL bug
-      template<>
-      struct and_with_two_args<mpl::_1,mpl::_2>
-      {
-          template <class A1, class A2>
-          struct apply : mpl::and_<A1,A2>
-          {};
-      };
-# endif 
-
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Class zip_iterator_base
-    //
-    // Builds and exposes the iterator facade type from which the zip 
-    // iterator will be derived.
-    //
-    template<typename IteratorTuple>
-    struct zip_iterator_base
-    {
-     private:
-        // Reference type is the type of the tuple obtained from the
-        // iterators' reference types.
-        typedef typename 
-        detail::tuple_of_references<IteratorTuple>::type reference;
-      
-        // Value type is the same as reference type.
-        typedef reference value_type;
-      
-        // Difference type is the first iterator's difference type
-        typedef typename iterator_traits<
-            typename mpl::front<IteratorTuple>::type
-            >::difference_type difference_type;
-      
-        // Traversal catetgory is the minimum traversal category in the 
-        // iterator tuple.
-        typedef typename 
-        detail::minimum_traversal_category_in_iterator_tuple<
-            IteratorTuple
-        >::type traversal_category;
-     public:
-      
-        // The iterator facade type from which the zip iterator will
-        // be derived.
-        typedef iterator_facade<
-            zip_iterator<IteratorTuple>,
-            value_type,  
-            traversal_category,
-            reference,
-            difference_type
-        > type;
-    };
-
-    template <>
-    struct zip_iterator_base<int>
-    {
-        typedef int type;
-    };
-  }
-  
-  /////////////////////////////////////////////////////////////////////
-  //
-  // zip_iterator class definition
-  //
-  template<typename IteratorTuple>
-  class zip_iterator : 
-    public detail::zip_iterator_base<IteratorTuple>::type
-  {  
-
-   // Typedef super_t as our base class. 
-   typedef typename 
-     detail::zip_iterator_base<IteratorTuple>::type super_t;
-
-   // iterator_core_access is the iterator's best friend.
-   friend class iterator_core_access;
-
-  public:
-    
-    // Construction
-    // ============
-    
-    // Default constructor
-    zip_iterator() { }
-
-    // Constructor from iterator tuple
-    zip_iterator(IteratorTuple iterator_tuple) 
-      : m_iterator_tuple(iterator_tuple) 
-    { }
-
-    // Copy constructor
-    template<typename OtherIteratorTuple>
-    zip_iterator(
-       const zip_iterator<OtherIteratorTuple>& other,
-       typename enable_if_convertible<
-         OtherIteratorTuple,
-         IteratorTuple
-         >::type* = 0
-    ) : m_iterator_tuple(other.get_iterator_tuple())
-    {}
-
-    // Get method for the iterator tuple.
-    const IteratorTuple& get_iterator_tuple() const
-    { return m_iterator_tuple; }
-
-  private:
-    
-    // Implementation of Iterator Operations
-    // =====================================
-    
-    // Dereferencing returns a tuple built from the dereferenced
-    // iterators in the iterator tuple.
-    typename super_t::reference dereference() const
-    { 
-        return fusion::generate(fusion::transform( 
-            get_iterator_tuple(),
-            detail::dereference_iterator()
-        ));
-    }
-
-    // Two zip iterators are equal if all iterators in the iterator
-    // tuple are equal. NOTE: It should be possible to implement this
-    // as
-    //
-    // return get_iterator_tuple() == other.get_iterator_tuple();
-    //
-    // but equality of tuples currently (7/2003) does not compile
-    // under several compilers. No point in bringing in a bunch
-    // of #ifdefs here.
-    //
-    template<typename OtherIteratorTuple>   
-    bool equal(const zip_iterator<OtherIteratorTuple>& other) const
-    {
-        return get_iterator_tuple() == other.get_iterator_tuple();
-    }
-
-    // Advancing a zip iterator means to advance all iterators in the
-    // iterator tuple.
-    void advance(typename super_t::difference_type n)
-    { 
-        fusion::for_each(
-            m_iterator_tuple,
-            detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n)
-          );
-    }
-    // Incrementing a zip iterator means to increment all iterators in
-    // the iterator tuple.
-    void increment()
-    { 
-        fusion::for_each(
-            m_iterator_tuple,
-            detail::increment_iterator()
-        );
-    }
-    
-    // Decrementing a zip iterator means to decrement all iterators in
-    // the iterator tuple.
-    void decrement()
-    { 
-        fusion::for_each(
-            m_iterator_tuple,
-            detail::decrement_iterator()
-        );
-    }
-    
-    // Distance is calculated using the first iterator in the tuple.
-    template<typename OtherIteratorTuple>
-      typename super_t::difference_type distance_to(
-        const zip_iterator<OtherIteratorTuple>& other
-        ) const
-    { 
-        return *fusion::begin(other.get_iterator_tuple()) - 
-            *fusion::begin(this->get_iterator_tuple());
-    }
-  
-    // Data Members
-    // ============
-    
-    // The iterator tuple.
-    IteratorTuple m_iterator_tuple;
- 
-  };
-
-  // Make function for zip iterator
-  //
-  template<typename IteratorTuple> 
-  zip_iterator<IteratorTuple> 
-  make_zip_iterator(IteratorTuple t)
-  { return zip_iterator<IteratorTuple>(t); }
-
-}
-
-#endif

test/zip_iterator_test.cpp

@@ -1,836 +0,0 @@
-// (C) Copyright Dave Abrahams and Thomas Becker 2003. Permission to
-// copy, use, modify, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. This software
-// is provided "as is" without express or implied warranty, and with
-// no claim as to its suitability for any purpose.
-//
-
-// File: 
-// =====
-// zip_iterator_test_main.cpp
-
-// Author:
-// =======
-// Thomas Becker
-
-// Created:
-// ========
-// Jul 15, 2003
-
-// Purpose:
-// ========
-// Test driver for zip_iterator.hpp
-
-// Compilers Tested:
-// =================
-// Metrowerks Codewarrior Pro 7.2, 8.3
-// gcc 2.95.3
-// gcc 3.2
-// Microsoft VC 6sp5 (test fails due to some compiler bug)
-// Microsoft VC 7 (works)
-// Microsoft VC 7.1
-// Intel 5
-// Intel 6
-// Intel 7.1
-// Intel 8
-// Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Includes
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#define FUSION_MAX_TUPLE_SIZE 13
-
-#include <boost/iterator/zip_iterator.hpp> // 2nd #include tests #include guard.
-#include <iostream>
-#include <vector>
-#include <list>
-#include <set>
-#include <functional>
-#include <boost/spirit/fusion/sequence/tuple.hpp>
-#include <boost/spirit/fusion/sequence/tuple20.hpp>
-#include <boost/spirit/fusion/sequence/make_tuple.hpp>
-#include <boost/spirit/fusion/algorithm/push_front.hpp>
-#include <boost/spirit/fusion/sequence/get.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/iterator/is_readable_iterator.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/detail/workaround.hpp>
-#include <stddef.h>
-
-template <class It>
-struct pure_traversal
-  : boost::detail::pure_traversal_tag<
-        typename boost::iterator_traversal<It>::type
-    >
-{};
-  
-/////////////////////////////////////////////////////////////////////////////
-//
-// Das Main Funktion
-//
-/////////////////////////////////////////////////////////////////////////////
-  
-int main( void )
-{
-
-  std::cout << "\n"
-            << "***********************************************\n"
-            << "*                                             *\n"
-            << "* Test driver for boost::zip_iterator         *\n"
-            << "* Copyright Thomas Becker 2003                *\n"
-            << "*                                             *\n"
-            << "***********************************************\n\n"
-            << std::flush;
-
-  size_t num_successful_tests = 0;
-  size_t num_failed_tests = 0;
-  
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator construction and dereferencing
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator construction and dereferencing: "
-            << std::flush;
-  
-  std::vector<double> vect1(3);
-  vect1[0] = 42.;
-  vect1[1] = 43.;
-  vect1[2] = 44.;
-
-  std::set<int> intset;
-  intset.insert(52);
-  intset.insert(53);
-  intset.insert(54);
-  //
-
-  typedef
-  boost::zip_iterator<
-      boost::fusion::tuple<
-          std::set<int>::iterator
-        , std::vector<double>::iterator
-      >
-  > zit_mixed;
-
-  zit_mixed zip_it_mixed = zit_mixed(
-    boost::fusion::make_tuple(
-        intset.begin()
-      , vect1.begin()
-    )
-  );
-
-  boost::fusion::tuple<int, double> val_tuple( 
-      *zip_it_mixed);
-  
-  boost::fusion::tuple<const int&, double&> ref_tuple(
-      *zip_it_mixed);
-
-  double dblOldVal = boost::fusion::get<1>(ref_tuple);
-  boost::fusion::get<1>(ref_tuple) -= 41.;
-
-  if( 52 == boost::fusion::get<0>(val_tuple) &&
-      42. == boost::fusion::get<1>(val_tuple) &&
-      52 == boost::fusion::get<0>(ref_tuple)  &&
-      1. == boost::fusion::get<1>(ref_tuple)  &&
-      1. == *vect1.begin()
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  // Undo change to vect1
-  boost::fusion::get<1>(ref_tuple) = dblOldVal;
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator with 12 components
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterators with 12 components:            "
-            << std::flush;
-            
-  // Declare 12 containers
-  //
-  std::list<int> li1;
-  li1.push_back(1);
-  std::set<int> se1;
-  se1.insert(2);
-  std::vector<int> ve1;
-  ve1.push_back(3);
-  //
-  std::list<int> li2;
-  li2.push_back(4);
-  std::set<int> se2;
-  se2.insert(5);
-  std::vector<int> ve2;
-  ve2.push_back(6);
-  //
-  std::list<int> li3;
-  li3.push_back(7);
-  std::set<int> se3;
-  se3.insert(8);
-  std::vector<int> ve3;
-  ve3.push_back(9);
-  //
-  std::list<int> li4;
-  li4.push_back(10);
-  std::set<int> se4;
-  se4.insert(11);
-  std::vector<int> ve4;
-  ve4.push_back(12);
-
-  // typedefs for cons lists of iterators.
-  typedef boost::fusion::tuple11<
-    std::set<int>::iterator, 
-      std::vector<int>::iterator,
-      std::list<int>::iterator, 
-      std::set<int>::iterator, 
-      std::vector<int>::iterator,
-      std::list<int>::iterator, 
-      std::set<int>::iterator, 
-      std::vector<int>::iterator,
-      std::list<int>::iterator, 
-      std::set<int>::iterator, 
-      std::vector<int>::const_iterator
-    > cons_11_its_type;
-  
-  //
-  typedef boost::fusion::meta::generate<
-      boost::fusion::meta::push_front<
-          cons_11_its_type,
-          std::list<int>::const_iterator
-      >::type
-  >::type cons_12_its_type;
-
-  // typedefs for cons lists for dereferencing the zip iterator
-  // made from the cons list above.
-  typedef boost::fusion::tuple11<
-    const int&, 
-      int&,
-      int&,
-      const int&,
-      int&,
-      int&,
-      const int&,
-      int&,
-      int&,
-      const int&,
-      const int&
-    > cons_11_refs_type;
-  //
-  typedef boost::fusion::meta::generate<
-      boost::fusion::meta::push_front<
-          cons_11_refs_type,
-          const int&
-      >::type
-  >::type cons_12_refs_type;
-
-  // typedef for zip iterator with 12 elements
-  typedef boost::zip_iterator<cons_12_its_type> zip_it_12_type;
-
-  // Declare a 12-element zip iterator.
-  zip_it_12_type zip_it_12(
-    cons_12_its_type(
-      li1.begin(), 
-        se1.begin(),
-          ve1.begin(),
-          li2.begin(), 
-          se2.begin(), 
-          ve2.begin(),
-          li3.begin(), 
-          se3.begin(), 
-          ve3.begin(),
-          li4.begin(), 
-          se4.begin(), 
-          ve4.begin()
-      )
-    );
-
-  // Dereference, mess with the result a little.
-  cons_12_refs_type zip_it_12_dereferenced(*zip_it_12);
-  boost::fusion::get<9>(zip_it_12_dereferenced) = 42;
-  
-  // Make a copy and move it a little to force some instantiations.
-  zip_it_12_type zip_it_12_copy(zip_it_12);
-  ++zip_it_12_copy;
-
-  if( boost::fusion::get<11>(zip_it_12.get_iterator_tuple()) == ve4.begin() &&
-      boost::fusion::get<11>(zip_it_12_copy.get_iterator_tuple()) == ve4.end() &&
-      1 == boost::fusion::get<0>(zip_it_12_dereferenced) &&
-      12 == boost::fusion::get<11>(zip_it_12_dereferenced) &&
-      42 == *(li4.begin())
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator incrementing and dereferencing
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator ++ and *:                       "
-            << std::flush;
-
-  std::vector<double> vect2(3);
-  vect2[0] = 2.2;
-  vect2[1] = 3.3;
-  vect2[2] = 4.4;
-  
-  boost::zip_iterator<
-    boost::fusion::tuple<
-      std::vector<double>::const_iterator, 
-      std::vector<double>::const_iterator
-      > 
-    >
-  zip_it_begin(
-    boost::fusion::make_tuple(
-     vect1.begin(),
-     vect2.begin()
-     )
-  );
-
-  boost::zip_iterator<
-    boost::fusion::tuple<
-      std::vector<double>::const_iterator, 
-      std::vector<double>::const_iterator
-      > 
-    >
-  zip_it_run(
-    boost::fusion::make_tuple(
-     vect1.begin(),
-     vect2.begin()
-     )
-  );
-
-  boost::zip_iterator<
-    boost::fusion::tuple<
-      std::vector<double>::const_iterator, 
-      std::vector<double>::const_iterator
-      > 
-    >
-  zip_it_end(
-    boost::fusion::make_tuple(
-     vect1.end(),
-     vect2.end()
-     )
-  );
-
-  if( zip_it_run == zip_it_begin &&
-      42. == boost::fusion::get<0>(*zip_it_run) &&
-      2.2 == boost::fusion::get<1>(*zip_it_run) &&
-      43. == boost::fusion::get<0>(*(++zip_it_run)) &&
-      3.3 == boost::fusion::get<1>(*zip_it_run) &&
-      44. == boost::fusion::get<0>(*(++zip_it_run)) &&
-      4.4 == boost::fusion::get<1>(*zip_it_run) &&
-      zip_it_end == ++zip_it_run
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator decrementing and dereferencing
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator -- and *:                       "
-            << std::flush;
-
-  if( zip_it_run == zip_it_end &&
-      zip_it_end == zip_it_run-- &&
-      44. == boost::fusion::get<0>(*zip_it_run) &&
-      4.4 == boost::fusion::get<1>(*zip_it_run) &&
-      43. == boost::fusion::get<0>(*(--zip_it_run)) &&
-      3.3 == boost::fusion::get<1>(*zip_it_run) &&
-      42. == boost::fusion::get<0>(*(--zip_it_run)) &&
-      2.2 == boost::fusion::get<1>(*zip_it_run) &&
-      zip_it_begin == zip_it_run
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator copy construction and equality
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator copy construction and equality: " 
-            << std::flush;
-
-  boost::zip_iterator<
-    boost::fusion::tuple<
-      std::vector<double>::const_iterator, 
-      std::vector<double>::const_iterator
-      >
-    > zip_it_run_copy(zip_it_run);
-
-  if(zip_it_run == zip_it_run && zip_it_run == zip_it_run_copy)
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator inequality
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator inequality:                     "
-            << std::flush;
-  
-  if(!(zip_it_run != zip_it_run_copy) && zip_it_run != ++zip_it_run_copy)
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator less than
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator less than:                      "
-            << std::flush;
-  
-  // Note: zip_it_run_copy == zip_it_run + 1
-  //
-  if( zip_it_run < zip_it_run_copy  &&
-      !( zip_it_run < --zip_it_run_copy) && 
-      zip_it_run == zip_it_run_copy
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator less than or equal
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "zip iterator less than or equal:             "
-            << std::flush;
-  
-  // Note: zip_it_run_copy == zip_it_run
-  //
-  ++zip_it_run;
-  zip_it_run_copy += 2;
-
-  if( zip_it_run <= zip_it_run_copy && 
-      zip_it_run <= --zip_it_run_copy && 
-      !( zip_it_run <= --zip_it_run_copy) && 
-      zip_it_run <= zip_it_run
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator greater than
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator greater than:                   "
-            << std::flush;
-  
-  // Note: zip_it_run_copy == zip_it_run - 1
-  //
-  if( zip_it_run > zip_it_run_copy && 
-      !( zip_it_run > ++zip_it_run_copy) && 
-      zip_it_run == zip_it_run_copy
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator greater than or equal
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator greater than or equal:          "
-            << std::flush;
-
-  ++zip_it_run;
-  
-  // Note: zip_it_run == zip_it_run_copy + 1
-  //
-  if( zip_it_run >= zip_it_run_copy && 
-      --zip_it_run >= zip_it_run_copy && 
-      ! (zip_it_run >= ++zip_it_run_copy) 
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator + int
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator + int:                          "
-            << std::flush;
-
-  // Note: zip_it_run == zip_it_run_copy - 1
-  //
-  zip_it_run = zip_it_run + 2;
-  ++zip_it_run_copy;
-
-  if( zip_it_run == zip_it_run_copy && zip_it_run == zip_it_begin + 3 )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator - int
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator - int:                          "
-            << std::flush;
-  
-  // Note: zip_it_run == zip_it_run_copy, and both are at end position
-  // 
-  zip_it_run = zip_it_run - 2;
-  --zip_it_run_copy;
-  --zip_it_run_copy;
-  
-  if( zip_it_run == zip_it_run_copy && (zip_it_run - 1) == zip_it_begin )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator +=
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator +=:                             "
-            << std::flush;
-            
-  // Note: zip_it_run == zip_it_run_copy, and both are at begin + 1
-  // 
-  zip_it_run += 2;
-  if( zip_it_run == zip_it_begin + 3 )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator -=
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator -=:                             "
-            << std::flush;
-
-  // Note: zip_it_run is at end position, zip_it_run_copy is at
-  // begin plus one.
-  // 
-  zip_it_run -= 2;
-  if( zip_it_run == zip_it_run_copy )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator getting member iterators
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator member iterators:               "
-            << std::flush;
-            
-  // Note: zip_it_run and zip_it_run_copy are both at
-  // begin plus one.
-  // 
-  if( boost::fusion::get<0>(zip_it_run.get_iterator_tuple()) == vect1.begin() + 1 &&
-      boost::fusion::get<1>(zip_it_run.get_iterator_tuple()) == vect2.begin() + 1
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Making zip iterators
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Making zip iterators:                        "
-            << std::flush;
-
-  std::vector<boost::fusion::tuple<double, double> >
-    vect_of_tuples(3);
-
-  std::copy(
-    boost::make_zip_iterator(
-    boost::fusion::make_tuple(
-      vect1.begin(), 
-      vect2.begin()
-      )
-    ),
-    boost::make_zip_iterator(
-    boost::fusion::make_tuple(
-      vect1.end(), 
-      vect2.end()
-      )
-    ),
-    vect_of_tuples.begin()
-  );
-
-  if( 42. == boost::fusion::get<0>(*vect_of_tuples.begin()) &&
-      2.2 == boost::fusion::get<1>(*vect_of_tuples.begin()) &&
-      43. == boost::fusion::get<0>(*(vect_of_tuples.begin() + 1)) &&
-      3.3 == boost::fusion::get<1>(*(vect_of_tuples.begin() + 1)) &&
-      44. == boost::fusion::get<0>(*(vect_of_tuples.begin() + 2)) &&
-      4.4 == boost::fusion::get<1>(*(vect_of_tuples.begin() + 2))
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator non-const --> const conversion
-  //
-  /////////////////////////////////////////////////////////////////////////////
-  
-  std::cout << "Zip iterator non-const to const conversion:  "
-            << std::flush;
-  
-  boost::zip_iterator<
-    boost::fusion::tuple<
-      std::set<int>::const_iterator,
-      std::vector<double>::const_iterator
-      >
-    > 
-  zip_it_const(
-    boost::fusion::make_tuple(
-      intset.begin(), 
-      vect2.begin()
-    )
-  );
-  //
-  boost::zip_iterator<
-    boost::fusion::tuple<
-      std::set<int>::iterator,
-      std::vector<double>::const_iterator
-      >
-    > 
-  zip_it_half_const(
-    boost::fusion::make_tuple(
-      intset.begin(), 
-      vect2.begin()
-    )
-  );
-  //
-  boost::zip_iterator<
-    boost::fusion::tuple<
-      std::set<int>::iterator,
-      std::vector<double>::iterator
-      >
-    > 
-  zip_it_non_const(
-    boost::fusion::make_tuple(
-      intset.begin(), 
-      vect2.begin()
-    )
-  );
-
-  zip_it_half_const = ++zip_it_non_const;
-  zip_it_const = zip_it_half_const;
-  ++zip_it_const;
-//  zip_it_non_const = ++zip_it_const;  // Error: can't convert from const to non-const
-  
-  if( 54 == boost::fusion::get<0>(*zip_it_const) &&
-      4.4 == boost::fusion::get<1>(*zip_it_const)  &&
-      53 == boost::fusion::get<0>(*zip_it_half_const)  &&
-      3.3 == boost::fusion::get<1>(*zip_it_half_const)
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-
-  /////////////////////////////////////////////////////////////////////////////
-  //
-  // Zip iterator categories
-  //
-  /////////////////////////////////////////////////////////////////////////////
-
-  std::cout << "Zip iterator categories:                     "
-            << std::flush;
-            
-  // The big iterator of the previous test has vector, list, and set iterators.
-  // Therefore, it must be bidirectional, but not random access.
-  bool bBigItIsBidirectionalIterator = boost::is_convertible<
-    boost::iterator_traversal<zip_it_12_type>::type
-        , boost::bidirectional_traversal_tag
-        >::value;
-
-  bool bBigItIsRandomAccessIterator = boost::is_convertible<
-    boost::iterator_traversal<zip_it_12_type>::type
-        , boost::random_access_traversal_tag
-        >::value;
-
-  // A combining iterator with all vector iterators must have random access
-  // traversal.
-  //
-  typedef boost::zip_iterator<
-    boost::fusion::tuple<
-      std::vector<double>::const_iterator, 
-      std::vector<double>::const_iterator
-      >
-    > all_vects_type;
-  
-  bool bAllVectsIsRandomAccessIterator = boost::is_convertible<
-    boost::iterator_traversal<all_vects_type>::type
-        , boost::random_access_traversal_tag
-    >::value;
-
-  // The big test.
-  if( bBigItIsBidirectionalIterator &&
-      ! bBigItIsRandomAccessIterator &&
-      bAllVectsIsRandomAccessIterator
-    )
-  {
-    ++num_successful_tests;
-    std::cout << "OK" << std::endl;
-  }
-  else
-  {
-    ++num_failed_tests = 0;
-    std::cout << "not OK" << std::endl;
-  }
-
-  // Done
-  //
-  std::cout << "\nTest Result:"
-            << "\n============"
-            << "\nNumber of successful tests: " << static_cast<unsigned int>(num_successful_tests)
-            << "\nNumber of failed tests: " << static_cast<unsigned int>(num_failed_tests)
-            << std::endl;
-
-  return num_failed_tests;
-}
-