This commit was manufactured by cvs2svn to create branch 'boostify'.

[SVN r8587]

doc/GNUmakefile

@@ -1,232 +0,0 @@
-# GNUmakefile for postprocessing PDF files
-#
-# <20> 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/pending/iterator_adaptors.hpp

@@ -0,0 +1,767 @@
+// (C) Copyright David Abrahams 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.
+//
+// (C) Copyright Jeremy Siek 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.
+
+#ifndef BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
+#define BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
+
+#include <boost/iterator.hpp>
+#include <boost/utility.hpp>
+#include <boost/compressed_pair.hpp>
+#include <boost/concept_check.hpp>
+
+// I was having some problems with VC6. I couldn't tell whether our hack for
+// stock GCC was causing problems so I needed an easy way to turn it on and
+// off. Now we can test the hack with various compilers and still have an 
+// "out" if it doesn't work. -dwa 7/31/00
+#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 && !defined(__STL_USE_NAMESPACES)
+# define BOOST_RELOPS_AMBIGUITY_BUG 1
+#endif
+
+namespace boost {
+
+// Just a "type envelope"; works around some MSVC deficiencies.
+template <class T>
+struct type {};
+
+
+//============================================================================
+// Concept checking classes that express the requirements for iterator
+// policies and adapted types. These classes are mostly for
+// documentation purposes, and are not used in this header file. They
+// merely provide a more succinct statement of what is expected of the
+// iterator policies.
+
+template <class Policies, class Adapted, class Traits>
+struct TrivialIteratorPoliciesConcept
+{
+  typedef typename Traits::reference Reference;
+  void constraints() {
+    function_requires< AssignableConcept<Policies> >();
+    function_requires< DefaultConstructibleConcept<Policies> >();
+    function_requires< AssignableConcept<Adapted> >();
+    function_requires< DefaultConstructibleConcept<Adapted> >();
+
+    const_constraints();
+  }
+  void const_constraints() const {
+    Reference r = p.dereference(type<Reference>(), x);
+    b = p.equal(x, x);
+  }
+  Policies p;
+  Adapted x;
+  mutable bool b;
+};
+
+template <class Policies, class Adapted, class Traits>
+struct ForwardIteratorPoliciesConcept
+{
+  void constraints() {
+    function_requires< 
+      TrivialIteratorPoliciesConcept<Policies, Adapted, Traits>
+      >();
+
+    p.increment(x);
+  }
+  Policies p;
+  Adapted x;
+};
+
+template <class Policies, class Adapted, class Traits>
+struct BidirectionalIteratorPoliciesConcept
+{
+  void constraints() {
+    function_requires< 
+      ForwardIteratorPoliciesConcept<Policies, Adapted, Traits>
+      >();
+
+    p.decrement(x);
+  }
+  Policies p;
+  Adapted x;
+};
+
+template <class Policies, class Adapted, class Traits>
+struct RandomAccessIteratorPoliciesConcept
+{
+  typedef typename Traits::difference_type DifferenceType;
+  void constraints() {
+    function_requires< 
+      BidirectionalIteratorPoliciesConcept<Policies, Adapted, Traits>
+      >();
+
+    p.advance(x, n);
+    const_constraints();
+  }
+  void const_constraints() const {
+    n = p.distance(type<DifferenceType>(), x, x);
+    b = p.less(x, x);
+  }
+  Policies p;
+  Adapted x;
+  mutable DifferenceType n;
+  mutable bool b;
+};
+
+
+//============================================================================
+// Default policies for iterator adaptors. You can use this as a base
+// class if you want to customize particular policies.
+struct default_iterator_policies
+{
+    // Some of these members were defined static, but Borland got confused
+    // and thought they were non-const. Also, Sun C++ does not like static
+    // function templates.
+
+    template <class Reference, class Iterator>
+    Reference dereference(type<Reference>, const Iterator& x) const
+        { return *x; }
+
+    template <class Iterator>
+    void increment(Iterator& x)
+        { ++x; }
+
+    template <class Iterator>
+    void decrement(Iterator& x)
+        { --x; }
+
+    template <class Iterator, class DifferenceType>
+    void advance(Iterator& x, DifferenceType n)
+        { x += n; }
+
+    template <class Difference, class Iterator1, class Iterator2>
+    Difference distance(type<Difference>, const Iterator1& x,
+                        const Iterator2& y) const
+        { return y - x; }
+
+    template <class Iterator1, class Iterator2>
+    bool equal(const Iterator1& x, const Iterator2& y) const
+        { return x == y; }
+
+    template <class Iterator1, class Iterator2>
+    bool less(const Iterator1& x, const Iterator2& y) const
+        { return x < y; }
+};
+
+// putting the comparisons in a base class avoids the g++ 
+// ambiguous overload bug due to the relops operators
+
+#ifdef BOOST_RELOPS_AMBIGUITY_BUG
+template <class Derived, class Base>
+struct iterator_comparisons : Base { };
+
+template <class D1, class D2, class Base1, class Base2>
+inline bool operator==(const iterator_comparisons<D1,Base1>& xb, 
+                       const iterator_comparisons<D2,Base2>& yb)
+{
+        const D1& x = static_cast<const D1&>(xb);
+    const D2& y = static_cast<const D2&>(yb);
+    return x.policies().equal(x.iter(), y.iter());
+}
+
+template <class D1, class D2, class Base1, class Base2>
+inline bool operator!=(const iterator_comparisons<D1,Base1>& xb, 
+                       const iterator_comparisons<D2,Base2>& yb)
+{
+    const D1& x = static_cast<const D1&>(xb);
+    const D2& y = static_cast<const D2&>(yb);
+    return !x.policies().equal(x.iter(), y.iter());
+}
+
+template <class D1, class D2, class Base1, class Base2>
+inline bool operator<(const iterator_comparisons<D1,Base1>& xb, 
+                      const iterator_comparisons<D2,Base2>& yb)
+{
+    const D1& x = static_cast<const D1&>(xb);
+    const D2& y = static_cast<const D2&>(yb);
+    return x.policies().less(x.iter(), y.iter());
+}
+
+template <class D1, class D2, class Base1, class Base2>
+inline bool operator>(const iterator_comparisons<D1,Base1>& xb, 
+                      const iterator_comparisons<D2,Base2>& yb)
+{ 
+    const D1& x = static_cast<const D1&>(xb);
+    const D2& y = static_cast<const D2&>(yb);
+    return x.policies().less(y.iter(), x.iter());
+}
+
+template <class D1, class D2, class Base1, class Base2>
+inline bool operator>=(const iterator_comparisons<D1,Base1>& xb, 
+                       const iterator_comparisons<D2,Base2>& yb)
+{
+    const D1& x = static_cast<const D1&>(xb);
+    const D2& y = static_cast<const D2&>(yb);
+    return !x.policies().less(x.iter(), y.iter());
+}
+
+template <class D1, class D2, class Base1, class Base2>
+inline bool operator<=(const iterator_comparisons<D1,Base1>& xb, 
+                       const iterator_comparisons<D2,Base2>& yb)
+{
+    const D1& x = static_cast<const D1&>(xb);
+    const D2& y = static_cast<const D2&>(yb);
+    return !x.policies().less(y.iter(), x.iter());
+}
+#endif
+
+//============================================================================
+// Some compilers (SGI MIPSpro 7.1.3.3) instantiate/compile member functions
+// whether or not they are used. The following functions make sure that
+// when the base iterators do not support particular operators, those
+// operators do not get used.
+
+namespace detail {
+
+  // Dummy version for iterators that don't support member access
+  template <class Iter, class Cat>
+  inline typename Iter::pointer
+  operator_arrow(const Iter&, Cat) {
+    typedef typename Iter::pointer Pointer;
+    return Pointer();
+  }
+  // Real version
+  template <class Iter>
+  inline typename Iter::pointer
+  operator_arrow(const Iter& i, std::forward_iterator_tag) {
+    return &(*i);
+  }
+
+  // Dummy version for iterators that don't support member access
+  template <class Iter, class Diff, class Cat>
+  inline void advance_impl(const Iter&, Diff, Cat) { }
+
+  // Real version
+  template <class Iter, class Diff>
+  inline typename Iter::pointer
+  advance_impl(const Iter& i, Diff n, std::random_access_iterator_tag) {
+#ifdef __MWERKS__
+        i.policies().advance<Iter>(iter(), n);
+#else
+        i.policies().advance(iter(), n);
+#endif
+  }
+
+} // namespace detail
+
+//============================================================================
+// iterator_adaptor - A generalized adaptor around an existing
+//   iterator, which is itself an iterator
+//
+//   Iterator - the iterator type being wrapped.
+//
+//   Policies - a set of policies determining how the resulting iterator
+//      works.
+//
+//   Traits - a class satisfying the same requirements as a specialization of
+//      std::iterator_traits for the resulting iterator.
+//
+template <class Iterator, class Policies, 
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+          class Traits
+#else
+          class Traits = std::iterator_traits<Iterator>
+#endif
+         >
+struct iterator_adaptor :
+#ifdef BOOST_RELOPS_AMBIGUITY_BUG
+    iterator_comparisons<
+          iterator_adaptor<Iterator,Policies,Traits>,
+#endif
+          boost::iterator<typename Traits::iterator_category, 
+              typename Traits::value_type, typename Traits::difference_type,
+              typename Traits::pointer, typename Traits::reference>
+#ifdef BOOST_RELOPS_AMBIGUITY_BUG
+>
+#endif
+{
+    typedef iterator_adaptor<Iterator, Policies, Traits> Self;
+public:
+    typedef typename Traits::difference_type difference_type;
+    typedef typename Traits::value_type value_type;
+    typedef typename Traits::pointer pointer;
+    typedef typename Traits::reference reference;
+    typedef typename Traits::iterator_category iterator_category;
+    typedef Iterator iterator_type;
+
+    iterator_adaptor() { }
+
+    iterator_adaptor(const Iterator& iter, const Policies& p = Policies())
+        : m_iter_p(iter, p) {}
+
+    template <class OtherIter, class OtherTraits>
+    iterator_adaptor (const iterator_adaptor<OtherIter, Policies,
+            OtherTraits>& src)
+            : m_iter_p(src.iter(), src.policies()) {
+    }
+
+    reference operator*() const {
+        return policies().dereference(type<reference>(), iter());
+    }
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning( disable : 4284 )
+#endif
+
+    pointer operator->() const
+        { return detail::operator_arrow(*this, iterator_category()); }
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+    reference operator[](difference_type n) const
+        { return *(*this + n); }
+    
+    Self& operator++() {
+#ifdef __MWERKS__
+        // Odd bug, MWERKS couldn't  deduce the type for the member template
+        // Workaround by explicitly specifying the type.
+        policies().increment<Iterator>(iter());
+#else
+        policies().increment(iter());
+#endif
+        return *this;
+    }
+
+    Self operator++(int) { Self tmp(*this); ++*this; return tmp; }
+    
+    Self& operator--() {
+#ifdef __MWERKS__
+        policies().decrement<Iterator>(iter());
+#else
+        policies().decrement(iter());
+#endif
+        return *this;
+    }
+    
+    Self operator--(int) { Self tmp(*this); --*this; return tmp; }
+
+    Self& operator+=(difference_type n) {
+        detail::advance_impl(*this, n, iterator_category());
+        return *this;
+    }
+  
+    Self& operator-=(difference_type n) {
+        detail::advance_impl(*this, -n, iterator_category());
+        return *this;
+    }
+
+    iterator_type base() const { return m_iter_p.first(); }
+
+private:
+    typedef Policies policies_type;
+    compressed_pair<Iterator,Policies> m_iter_p;
+public: // too many compilers have trouble when these are private.
+    Policies& policies() { return m_iter_p.second(); }
+    const Policies& policies() const { return m_iter_p.second(); }
+    Iterator& iter() { return m_iter_p.first(); }
+    const Iterator& iter() const { return m_iter_p.first(); }
+};
+
+
+template <class Iterator, class Policies, class Traits>
+iterator_adaptor<Iterator,Policies,Traits>
+operator-(iterator_adaptor<Iterator,Policies,Traits> p, const typename Traits::difference_type x)
+{
+    return p -= x;
+}
+
+template <class Iterator, class Policies, class Traits>
+iterator_adaptor<Iterator,Policies,Traits>
+operator+(iterator_adaptor<Iterator,Policies,Traits> p, typename Traits::difference_type x)
+{
+    return p += x;
+}
+
+template <class Iterator, class Policies, class Traits>
+iterator_adaptor<Iterator,Policies,Traits>
+operator+(typename Traits::difference_type x, iterator_adaptor<Iterator,Policies,Traits> p)
+{
+    return p += x;
+}
+
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+typename Traits1::difference_type operator-(
+    const iterator_adaptor<Iterator1,Policies,Traits1>& x,
+    const iterator_adaptor<Iterator2,Policies,Traits2>& y )
+{
+    typedef typename Traits1::difference_type difference_type;
+    return x.policies().distance(type<difference_type>(), y.iter(), x.iter());
+}
+
+#ifndef BOOST_RELOPS_AMBIGUITY_BUG
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+inline bool 
+operator==(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+    return x.policies().equal(x.iter(), y.iter());
+}
+
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+inline bool 
+operator<(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+    return x.policies().less(x.iter(), y.iter());
+}
+
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+inline bool 
+operator>(const iterator_adaptor<Iterator1,Policies,Traits1>& x,
+          const iterator_adaptor<Iterator2,Policies,Traits2>& y) { 
+    return x.policies().less(y.iter(), x.iter());
+}
+
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+inline bool 
+operator>=(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+    return !x.policies().less(x.iter(), y.iter());
+}
+
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+inline bool 
+operator<=(const iterator_adaptor<Iterator1,Policies,Traits1>& x,
+           const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+    return !x.policies().less(y.iter(), x.iter());
+}
+
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+inline bool 
+operator!=(const iterator_adaptor<Iterator1,Policies,Traits1>& x, 
+           const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+    return !x.policies().equal(x.iter(), y.iter());
+}
+#endif
+
+//=============================================================================
+// iterator_adaptors - A type generator that simplifies creating
+//   mutable/const pairs of iterator adaptors.
+
+template <class Iterator, class ConstIterator, 
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+          class Traits, 
+          class ConstTraits,
+#else
+          class Traits = std::iterator_traits<Iterator>, 
+          class ConstTraits = std::iterator_traits<ConstIterator>,
+#endif
+          class Policies = default_iterator_policies>
+class iterator_adaptors
+{
+public:
+    typedef iterator_adaptor<Iterator, Policies, Traits> iterator;
+    typedef iterator_adaptor<ConstIterator, Policies, ConstTraits> 
+      const_iterator;
+};
+
+
+//=============================================================================
+// Transform Iterator Adaptor
+//
+// Upon deference, apply some unary function object and return the
+// result by value.
+
+template <class AdaptableUnaryFunction>
+struct transform_iterator_policies : public default_iterator_policies
+{
+    transform_iterator_policies() { }
+    transform_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
+    
+    template <class Reference, class Iterator>
+    Reference dereference(type<Reference>, const Iterator& iter) const
+        { return m_f(*iter); }
+
+    AdaptableUnaryFunction m_f;
+};
+
+template <class AdaptableUnaryFunction, class IteratorTraits>
+struct transform_iterator_traits {
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+    typedef value_type reference;
+    typedef value_type* pointer;
+    typedef typename IteratorTraits::difference_type difference_type;
+    typedef typename IteratorTraits::iterator_category iterator_category;
+};
+  
+template <class AdaptableUnaryFunction,
+          class Iterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+          class Traits = std::iterator_traits<Iterator>
+#else
+          class Traits
+#endif
+         >
+struct transform_iterator
+{
+    typedef transform_iterator_traits<AdaptableUnaryFunction,Traits>
+      TransTraits;
+    typedef iterator_adaptor<Iterator, 
+      transform_iterator_policies<AdaptableUnaryFunction>, TransTraits>
+      type;
+};
+
+
+//=============================================================================
+// Indirect Iterators Adaptor
+
+// Given a pointer to pointers (or iterator to iterators),
+// apply a double dereference inside operator*().
+//
+// We use the term "outer" to refer to the first level iterator type
+// and "inner" to refer to the second level iterator type.  For
+// example, given T**, T* is the inner iterator type and T** is the
+// outer iterator type. Also, const T* would be the const inner
+// iterator.
+
+// We tried to implement this with transform_iterator, but that required
+// using boost::remove_ref, which is not compiler portable.
+
+struct indirect_iterator_policies : public default_iterator_policies
+{
+    template <class Reference, class Iterator>
+    Reference dereference(type<Reference>, const Iterator& x) const
+        { return **x; }
+};
+
+template <class OuterIterator, class InnerIterator,
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+          class OuterTraits,
+          class InnerTraits
+#else
+          class OuterTraits = std::iterator_traits<OuterIterator>,
+          class InnerTraits = std::iterator_traits<InnerIterator>
+#endif
+       >
+struct indirect_traits
+{
+    typedef typename OuterTraits::difference_type difference_type;
+    typedef typename InnerTraits::value_type value_type;
+    typedef typename InnerTraits::pointer pointer;
+    typedef typename InnerTraits::reference reference;
+    typedef typename OuterTraits::iterator_category iterator_category;
+};
+
+template <class OuterIterator,      // Mutable or Immutable, does not matter
+          class InnerIterator,      // Mutable -> mutable indirect iterator
+                                    // Immutable -> immutable indirect iterator
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+          class OuterTraits,
+          class InnerTraits
+#else
+          class OuterTraits = std::iterator_traits<OuterIterator>,
+          class InnerTraits = std::iterator_traits<InnerIterator>
+#endif
+           >
+struct indirect_iterator
+{
+    typedef iterator_adaptor<OuterIterator,
+        indirect_iterator_policies,
+        indirect_traits<OuterIterator, InnerIterator,
+                        OuterTraits, InnerTraits>
+    > type;
+};
+
+template <class OuterIterator,      // Mutable or Immutable, does not matter
+          class InnerIterator,      // Mutable
+          class ConstInnerIterator, // Immutable
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+          class OuterTraits,
+          class InnerTraits,
+          class ConstInnerTraits
+#else
+          class OuterTraits = std::iterator_traits<OuterIterator>,
+          class InnerTraits = std::iterator_traits<InnerIterator>,
+          class ConstInnerTraits = std::iterator_traits<ConstInnerIterator>
+#endif
+           >
+struct indirect_iterators
+{
+    typedef iterator_adaptors<OuterIterator, OuterIterator,
+        indirect_traits<OuterIterator, InnerIterator,
+                        OuterTraits, InnerTraits>,
+        indirect_traits<OuterIterator, ConstInnerIterator,
+                        OuterTraits, ConstInnerTraits>,
+        indirect_iterator_policies
+        > Adaptors;
+    typedef typename Adaptors::iterator iterator;
+    typedef typename Adaptors::const_iterator const_iterator;
+};
+
+
+//=============================================================================
+// Reverse Iterators Adaptor
+
+struct reverse_iterator_policies
+{
+    template <class Reference, class Iterator>
+    Reference dereference(type<Reference>, const Iterator& x) const
+        { return *boost::prior(x); }
+    
+    template <class Iterator>
+    void increment(Iterator& x) const
+        { --x; }
+    
+    template <class Iterator>
+    void decrement(Iterator& x) const
+        { ++x; }
+    
+    template <class Iterator, class DifferenceType>
+    void advance(Iterator& x, DifferenceType n) const
+        { x -= n; }
+    
+    template <class Difference, class Iterator1, class Iterator2>
+    Difference distance(type<Difference>, const Iterator1& x, 
+                        const Iterator2& y) const
+        { return x - y; }
+    
+    template <class Iterator1, class Iterator2>
+    bool equal(const Iterator1& x, const Iterator2& y) const
+        { return x == y; }
+    
+    template <class Iterator1, class Iterator2>
+    bool less(const Iterator1& x, const Iterator2& y) const
+        { return y < x; }
+};
+  
+template <class Iterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+          class Traits = std::iterator_traits<Iterator>
+#else
+          class Traits
+#endif
+         >
+struct reverse_iterator
+{
+    typedef iterator_adaptor<Iterator, reverse_iterator_policies,
+        Traits> type;
+};
+
+template <class ConstIterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+          class ConstTraits = std::iterator_traits<ConstIterator>
+#else
+          class ConstTraits
+#endif
+         >
+struct const_reverse_iterator
+{
+    typedef iterator_adaptor<ConstIterator, reverse_iterator_policies,
+        ConstTraits> type;
+};
+
+template <class Iterator, class ConstIterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+          class Traits = std::iterator_traits<Iterator>, 
+          class ConstTraits = std::iterator_traits<ConstIterator>
+#else
+          class Traits,
+          class ConstTraits
+#endif
+         >
+struct reverse_iterators
+{
+    typedef iterator_adaptors<Iterator,ConstIterator,Traits,ConstTraits,
+        reverse_iterator_policies> Adaptor;
+    typedef typename Adaptor::iterator iterator;
+    typedef typename Adaptor::const_iterator const_iterator;
+};
+
+//=============================================================================
+// Projection Iterators Adaptor
+
+template <class AdaptableUnaryFunction>
+struct projection_iterator_policies : public default_iterator_policies
+{
+    projection_iterator_policies() { }
+    projection_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
+
+    template <class Reference, class Iterator>
+    Reference dereference (type<Reference>, Iterator const& iter) const {
+        return m_f(*iter);
+    }
+
+    AdaptableUnaryFunction m_f;    
+};
+
+template <class AdaptableUnaryFunction, class Traits>
+struct projection_iterator_traits {
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+    typedef value_type& reference;
+    typedef value_type* pointer;
+    typedef typename Traits::difference_type difference_type;
+    typedef typename Traits::iterator_category iterator_category;
+};
+
+template <class AdaptableUnaryFunction, class Traits>
+struct const_projection_iterator_traits {
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+    typedef value_type const& reference;
+    typedef value_type const* pointer;
+    typedef typename Traits::difference_type difference_type;
+    typedef typename Traits::iterator_category iterator_category;
+};
+
+template <class AdaptableUnaryFunction, class Iterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+        class Traits = std::iterator_traits<Iterator>
+#else
+        class Traits
+#endif
+        >
+struct projection_iterator {
+    typedef projection_iterator_traits<AdaptableUnaryFunction, Traits>
+            Projection_Traits;
+    typedef iterator_adaptor<Iterator,
+            projection_iterator_policies<AdaptableUnaryFunction>,
+            Projection_Traits> type;
+};
+
+template <class AdaptableUnaryFunction, class Iterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+        class Traits = std::iterator_traits<Iterator>
+#else
+        class Traits
+#endif
+        >
+struct const_projection_iterator {
+    typedef const_projection_iterator_traits<AdaptableUnaryFunction,
+            Traits> Projection_Traits;
+    typedef iterator_adaptor<Iterator,
+            projection_iterator_policies<AdaptableUnaryFunction>,
+            Projection_Traits> type;
+};
+
+template <class AdaptableUnaryFunction, class Iterator, class ConstIterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+        class Traits = std::iterator_traits<Iterator>,
+        class ConstTraits = std::iterator_traits<ConstIterator>
+#else
+        class Traits,
+        class ConstTraits
+#endif
+        >
+struct projection_iterators {
+    typedef projection_iterator_traits<AdaptableUnaryFunction, Traits>
+            Projection_Traits;
+    typedef const_projection_iterator_traits<AdaptableUnaryFunction,
+            ConstTraits> Const_Projection_Traits;
+    typedef iterator_adaptors<Iterator, ConstIterator,
+            Projection_Traits, Const_Projection_Traits,
+            projection_iterator_policies<AdaptableUnaryFunction> > Adaptors;
+    typedef typename Adaptors::iterator iterator;
+    typedef typename Adaptors::const_iterator const_iterator;
+};
+
+} // namespace boost
+
+#endif
+
+
+