Moved pointer parameter

[SVN r9348]

doc/GNUmakefile

@@ -1,232 +0,0 @@
-# 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/counting_iterator.hpp

@@ -0,0 +1,215 @@
+// (C) Copyright David Abrahams and Jeremy Siek 2000-2001. 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.
+//
+// See http://www.boost.org for most recent version including documentation.
+//
+// Supplies:
+//
+//   template <class Incrementable> class counting_iterator_traits;
+//   template <class Incrementable> class counting_iterator_policies;
+//
+//     Iterator traits and policies for adapted iterators whose dereferenced
+//     value progresses through consecutive values of Incrementable when the
+//     iterator is derferenced.
+//
+//   template <class Incrementable> struct counting_iterator_generator;
+//
+//     A "type generator" whose nested type "type" is a counting iterator as
+//     described above.
+//
+//   template <class Incrementable>
+//     typename counting_iterator_generator<Incrementable>::type
+//     make_counting_iterator(Incrementable);
+//
+//     A function which produces an adapted counting iterator over values of
+//     Incrementable.
+// 
+// Revision History
+// 14 Feb 2001  Removed unnecessary typedefs from counting_iterator_traits
+//              (Jeremy Siek)
+// 11 Feb 2001  Use BOOST_STATIC_CONSTANT (Dave Abrahams)
+// 11 Feb 2001  Clean up after John Maddocks's (finally effective!) Borland
+//              fixes (David Abrahams).
+// 10 Feb 2001  Use new iterator_adaptor<> interface (David Abrahams)
+// 10 Feb 2001  Rolled in supposed Borland fixes from John Maddock, but not
+//              seeing any improvement yet (David Abrahams)
+// 09 Feb 2001  Factored out is_numeric computation. Borland still
+//              unhappy :( (David Abrahams)
+// 08 Feb 2001  Beginning of a failed attempt to appease Borland
+//              (David Abrahams)
+// 07 Feb 2001  rename counting_iterator() -> make_counting_iterator()
+//              (David Abrahams)        
+// 04 Feb 2001  Added counting_iterator_generator; updated comments
+//              (David Abrahams)
+// 24 Jan 2001  initial revision, based on Jeremy Siek's
+//              boost/pending/integer_range.hpp (David Abrahams)
+
+#ifndef BOOST_COUNTING_ITERATOR_HPP_DWA20000119
+# define BOOST_COUNTING_ITERATOR_HPP_DWA20000119
+
+# include <boost/config.hpp>
+# include <boost/detail/iterator.hpp>
+# include <boost/iterator_adaptors.hpp>
+# include <boost/type_traits.hpp>
+# include <boost/detail/numeric_traits.hpp>
+# include <boost/static_assert.hpp>
+# ifndef BOOST_NO_LIMITS
+#  include <limits>
+# endif
+
+namespace boost {
+
+namespace detail {
+
+  // Template class counting_iterator_traits_select -- choose an
+  // iterator_category and difference_type for a counting_iterator at
+  // compile-time based on whether or not it wraps an integer or an iterator,
+  // using "poor man's partial specialization".
+  template <bool is_integer> struct counting_iterator_traits_select;
+
+  // Incrementable is an iterator type
+  template <>
+  struct counting_iterator_traits_select<false>
+  {
+      template <class Incrementable>
+      struct traits
+      {
+       private:
+          typedef boost::detail::iterator_traits<Incrementable> x;
+       public:
+          typedef typename x::iterator_category iterator_category;
+          typedef typename x::difference_type difference_type;
+      };
+  };
+
+  // Incrementable is a numeric type
+  template <>
+  struct counting_iterator_traits_select<true>
+  {
+      template <class Incrementable>
+      struct traits
+      {
+          typedef typename
+            boost::detail::numeric_traits<Incrementable>::difference_type
+          difference_type;
+          typedef std::random_access_iterator_tag iterator_category;
+      };
+  };
+
+  // Template class distance_policy_select -- choose a policy for computing the
+  // distance between counting_iterators at compile-time based on whether or not
+  // the iterator wraps an integer or an iterator, using "poor man's partial
+  // specialization".
+
+  template <bool is_integer> struct distance_policy_select;
+
+  // A policy for wrapped iterators
+  template <>
+  struct distance_policy_select<false>
+  {
+      template <class Distance, class Incrementable>
+      struct policy {
+          static Distance distance(Incrementable x, Incrementable y)
+              { return boost::detail::distance(x, y); }
+      };
+  };
+
+  // A policy for wrapped numbers
+  template <>
+  struct distance_policy_select<true>
+  {
+      template <class Distance, class Incrementable>
+      struct policy {
+          static Distance distance(Incrementable x, Incrementable y)
+              { return numeric_distance(x, y); }
+      };
+  };
+
+  // Try to detect numeric types at compile time in ways compatible with the
+  // limitations of the compiler and library.
+  template <class T>
+  struct is_numeric {
+    // For a while, this wasn't true, but we rely on it below. This is a regression assert.
+    BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
+# else
+#  if !defined(__BORLANDC__)
+    BOOST_STATIC_CONSTANT(bool, value = (
+        boost::is_convertible<int,T>::value && boost::is_convertible<T,int>::value));
+#  else
+    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
+#  endif
+# endif
+  };
+
+  // Compute the distance over arbitrary numeric and/or iterator types
+  template <class Distance, class Incrementable>
+  Distance any_distance(Incrementable start, Incrementable finish, Distance* = 0)
+  {
+    
+      return distance_policy_select<(
+          is_numeric<Incrementable>::value)>::template
+          policy<Distance, Incrementable>::distance(start, finish);
+  }
+  
+} // namespace detail
+
+template <class Incrementable>
+struct counting_iterator_traits {
+ private:
+    typedef ::boost::detail::counting_iterator_traits_select<(
+        ::boost::detail::is_numeric<Incrementable>::value
+        )> binder;
+    typedef typename binder::template traits<Incrementable> traits;
+ public:
+    typedef typename traits::difference_type difference_type;
+    typedef typename traits::iterator_category iterator_category;
+};
+
+template <class Incrementable>
+struct counting_iterator_policies : public default_iterator_policies
+{
+    const Incrementable& dereference(type<const Incrementable&>, const Incrementable& i) const
+        { return i; }
+
+    template <class Difference, class Iterator1, class Iterator2>
+    Difference distance(type<Difference>, const Iterator1& x,
+                        const Iterator2& y) const
+    {
+        return boost::detail::any_distance<Difference>(x, y);//,(Difference*)());
+    }
+};
+
+// A type generator for counting iterators
+template <class Incrementable>
+struct counting_iterator_generator
+{
+    typedef counting_iterator_traits<Incrementable> traits;
+    
+    typedef iterator_adaptor<Incrementable,
+        counting_iterator_policies<Incrementable>,
+        Incrementable,
+        const Incrementable&,
+        typename traits::iterator_category,
+        typename traits::difference_type,
+        const Incrementable*
+    > type;
+};
+
+// Manufacture a counting iterator for an arbitrary incrementable type
+template <class Incrementable>
+inline typename counting_iterator_generator<Incrementable>::type
+make_counting_iterator(Incrementable x)
+{
+  typedef typename counting_iterator_generator<Incrementable>::type result_t;
+  return result_t(x);
+}
+
+
+} // namespace boost
+
+#endif // BOOST_COUNTING_ITERATOR_HPP_DWA20000119