STLSoft: stlsoft/util/std/iterator_helper.hpp Source File

00001 /* /////////////////////////////////////////////////////////////////////////
00002  * File:        stlsoft/util/std/iterator_helper.hpp
00003  *
00004  * Purpose:     Definition of iterator class templates and macros for
00005  *              abstracting away standard library inconsistencies.
00006  *
00007  * Created:     2nd January 2000
00008  * Updated:     9th March 2010
00009  *
00010  * Home:        http://stlsoft.org/
00011  *
00012  * Copyright (c) 2000-2010, Matthew Wilson and Synesis Software
00013  * All rights reserved.
00014  *
00015  * Redistribution and use in source and binary forms, with or without
00016  * modification, are permitted provided that the following conditions are met:
00017  *
00018  * - Redistributions of source code must retain the above copyright notice, this
00019  *   list of conditions and the following disclaimer.
00020  * - Redistributions in binary form must reproduce the above copyright notice,
00021  *   this list of conditions and the following disclaimer in the documentation
00022  *   and/or other materials provided with the distribution.
00023  * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
00024  *   any contributors may be used to endorse or promote products derived from
00025  *   this software without specific prior written permission.
00026  *
00027  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00028  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00029  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00030  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00031  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00032  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00033  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00034  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00035  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00036  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00037  * POSSIBILITY OF SUCH DAMAGE.
00038  *
00039  * ////////////////////////////////////////////////////////////////////// */
00040 
00041 
00049 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00050 #define STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00051 
00052 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00053 # define STLSOFT_VER_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER_MAJOR     5
00054 # define STLSOFT_VER_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER_MINOR     3
00055 # define STLSOFT_VER_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER_REVISION  1
00056 # define STLSOFT_VER_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER_EDIT      109
00057 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00058 
00059 /* /////////////////////////////////////////////////////////////////////////
00060  * Compatibility
00061  */
00062 
00063 /*
00064 [<[STLSOFT-AUTO:NO-UNITTEST]>]
00065 [Incompatibilies-start]
00066 STLSOFT_COMPILER_IS_WATCOM:
00067 [Incompatibilies-end]
00068  */
00069 
00070 /* /////////////////////////////////////////////////////////////////////////
00071  * Includes
00072  */
00073 
00074 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00075 # include <stlsoft/stlsoft.h>
00076 #endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */
00077 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_LIBRARY_DISCRIMINATOR
00078 # include <stlsoft/util/std/library_discriminator.hpp>
00079 #endif /* !STLSOFT_INCL_STLSOFT_UTIL_STD_LIBRARY_DISCRIMINATOR */
00080 
00081 #ifndef STLSOFT_INCL_ITERATOR
00082 # define STLSOFT_INCL_ITERATOR
00083 # include <iterator>    // for std::iterator, std::reverse_iterator, std::reverse_bidirectional_iterator
00084 #endif /* !STLSOFT_INCL_ITERATOR */
00085 
00086 #ifdef STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED_XXXX
00087 # ifndef STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_POINTER
00088 #  include <stlsoft/meta/typefixer/pointer.hpp>
00089 # endif /* !STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_POINTER */
00090 # ifndef STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_POINTER_TYPE
00091 #  include <stlsoft/meta/typefixer/pointer_type.hpp>
00092 # endif /* !STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_POINTER_TYPE */
00093 # ifndef STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_REFERENCE
00094 #  include <stlsoft/meta/typefixer/reference.hpp>
00095 # endif /* !STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_REFERENCE */
00096 # ifndef STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_REFERENCE_TYPE
00097 #  include <stlsoft/meta/typefixer/reference_type.hpp>
00098 # endif /* !STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_REFERENCE_TYPE */
00099 #endif /* STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED */
00100 
00101 /* /////////////////////////////////////////////////////////////////////////
00102  * Warnings
00103  */
00104 
00105 /* This is here temporarily, until a better solution can be found. */
00106 #ifdef STLSOFT_COMPILER_IS_MSVC
00107 # pragma warning(disable : 4097)    // suppresses: typedef-name 'identifier1' used as synonym for class-name 'identifier2'
00108 #endif /* compiler */
00109 
00110 /* /////////////////////////////////////////////////////////////////////////
00111  * Namespace
00112  */
00113 
00114 #ifndef _STLSOFT_NO_NAMESPACE
00115 namespace stlsoft
00116 {
00117 #endif /* _STLSOFT_NO_NAMESPACE */
00118 
00119 /* /////////////////////////////////////////////////////////////////////////
00120  * Tested compatibilities
00121  */
00122 
00123 #if !defined(STLSOFT_OVERRIDE_COMPILER_STD_LIBRARY_CHECK)
00124 
00125 # if 0
00126     /* Now we Must be either Dinkumware or STLport if compiling with Intel or Visual C++
00127      */
00128 
00129 #    if (   defined(STLSOFT_COMPILER_IS_INTEL) || \
00130             (   defined(STLSOFT_COMPILER_IS_MSVC) && \
00131                 _MSC_VER >= 1200 && \
00132                 _MSC_VER < 1310)) && \
00133         (   !defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC) && \
00134             !defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT))
00135 #     error When compiling with Intel C/C++ or Microsoft Visual C++, only the Dinkumware or STLport STL implementations are currently supported.
00136 #     error  Please contact Synesis Software (www.synesis.com.au) if you need to support a different STL implementation with these compilers.
00137 #    endif /* (Intel || MSVC) && !DinkumWare && !STLport */
00138 # endif /* 0 */
00139 
00140 #endif /* !STLSOFT_OVERRIDE_COMPILER_STD_LIBRARY_CHECK */
00141 
00142 /* /////////////////////////////////////////////////////////////////////////
00143  * Iterator macros
00144  */
00145 
00146 /* iterator
00147  *
00148  * There are
00149  *
00150  * 1. Form 1. This is the standard (C++-98: 24.2) form, and looks like the following
00151  *
00152  *    template< typename C
00153  *            , typename V
00154  *            , typename D = ptrdiff_t
00155  *            , typename P = V*
00156  *            , typename R = V&
00157  *            >
00158  *    struct iterator
00159  *    {
00160  *      typedef C   iterator_category;
00161  *      typedef V   value_type;
00162  *      typedef D  difference_type;
00163  *      typedef P  pointer;
00164  *      typedef R  reference;
00165  *    };
00166  *
00167  * 2. Form 2. This is found with Dinkumware / Visual C++ (versions 4.2, 5.0, 6.0)
00168  *
00169  *    template< typename C
00170  *            , typename V
00171  *            , typename D = ptrdiff_t
00172  *            >
00173  *    struct iterator
00174  *    {
00175  *      typedef C iterator_category;
00176  *      typedef V value_type;
00177  *      typedef D distance_type;
00178  *    };
00179  *
00180  * 3. Form 3. This is found in quite old versions of the STL, and in fact does not define
00181  *            an iterator template at all. Each container has its own iterator type
00182  */
00183 
00184 
00185 #ifdef STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00186 # undef STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00187 #endif /* !STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT */
00188 
00189 #ifdef STLSOFT_ITERATOR_ITERATOR_FORM2_SUPPORT
00190 # undef STLSOFT_ITERATOR_ITERATOR_FORM2_SUPPORT
00191 #endif /* !STLSOFT_ITERATOR_ITERATOR_FORM2_SUPPORT */
00192 
00193 #ifdef STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT
00194 # undef STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT
00195 #endif /* !STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT */
00196 
00197 
00198 #if defined(STLSOFT_COMPILER_IS_GCC) && \
00199     __GNUC__ < 3
00200  /* GCC 2.95 */
00201 # define STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT
00202 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_BORLAND)
00203 #  define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00204 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC)
00205 # if  STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_4_2 || \
00206       STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_5_0 || \
00207       STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_6_0
00208  /* Visual C++ + Dinkumware (pre v7.0) */
00209 #  define STLSOFT_ITERATOR_ITERATOR_FORM2_SUPPORT
00210 # else
00211 #  define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00212 # endif /* STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC */
00213 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_MSL)
00214 # define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00215 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
00216 # define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00217 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_HP_SGI)
00218 # if defined(__STL_USE_NAMESPACES)
00219 #  define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00220 # else /* ? __STL_USE_NAMESPACES */
00221 #  define STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT
00222 # endif /* __STL_USE_NAMESPACES */
00223 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_HP_SGI_GNU)
00224 # define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00225 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_HP_RW)
00226 # define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00227 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_SUNPRO_RW)
00228 # define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00229 #elif defined(STLSOFT_CF_STD_LIBRARY_IS_WATCOM_PATCH)
00230 # define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00231 #else
00232 # error Library version not recognised
00233 #endif /* library */
00234 
00235 
00236 /* reverse_iterator
00237  *
00238  * There are four known forms for reverse_iterators:
00239  *
00240  * 1. Form 1. This is the standard (C++-98: 24.4.1.1) form, and looks like the following
00241  *
00242  *    template <typename I>
00243  *      : public iterator<  typename iterator_traits<I>::iterator_category,
00244  *                          typename iterator_traits<I>::value_type,
00245  *                          typename iterator_traits<I>::difference_type,
00246  *                          typename iterator_traits<I>::pointer,
00247  *                          typename iterator_traits<I>::reference>
00248  *    {
00249  *      . . .
00250  *      typedef I                                               iterator_type;
00251  *      typedef typename iterator_traits<I>::difference_type    difference_type;
00252  *      typedef typename iterator_traits<I>::reference          reference;
00253  *      typedef typename iterator_traits<I>::pointer            pointer;
00254  *      . . .
00255  *    };
00256  *
00257  *
00258  * 2. Form 2. This is effectively standard, but does not derive from std::iterator. It looks
00259  *            like the following
00260  *
00261  *    template <typename I>
00262  *    {
00263  *      typedef typename iterator_traits<I>::iterator_category  iterator_category;
00264  *      typedef typename iterator_traits<I>::value_type         value_type;
00265  *      typedef typename iterator_traits<I>::difference_type    difference_type;
00266  *      typedef typename iterator_traits<I>::pointer            pointer;
00267  *      typedef typename iterator_traits<I>::reference          reference;
00268  *      . . .
00269  *    };
00270  *
00271  * 3. Form 3.
00272  *
00273  *    template< typename I
00274  *            , typename V
00275  *            , typename R = V&
00276  *            , typename P = V*
00277  *            , typename D = ptrdiff_t
00278  *            >
00279  *      : public _Ranit<V, D>
00280  *    {
00281  *      . . .
00282  *      typedef _Rt reference_type;
00283  *      typedef _Pt pointer_type;
00284  *      . . .
00285  *    };
00286  *
00287  *
00288  * 4. Form 4.
00289  *
00290  *    template< typename I
00291  *            , typename IC
00292  *            , typename V
00293  *            , typename R = V&
00294  *            , typename P = V*
00295  *            , typename D = ptrdiff_t
00296  *            >
00297  *    class reverse_iterator
00298  *      : public iterator<IC, V, D, P, R>
00299  *    {
00300  *      typedef D difference_type;
00301  *      typedef V value_type;
00302  *      typedef R reference;
00303  *      typedef P pointer;
00304  *      . . .
00305  *    };
00306  *
00307  *
00308  * 5. Form 5.
00309  *
00310  *    template< typename I
00311  *            , typename V
00312  *            , typename R = V&
00313  *            , typename D = ptrdiff_t
00314  *            >
00315  *    class reverse_iterator
00316  *      : public iterator<I, V, R, D>
00317  *    {
00318  *      typedef random_access_iterator_tag  iterator_category;
00319  *      typedef V                           value_type;
00320  *      typedef D                           difference_type;
00321  *      typedef V*                          pointer;
00322  *      typedef R                           reference;
00323  *      . . .
00324  *    };
00325  *
00326  */
00327 
00328 #ifdef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00329 # undef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00330 #endif /* !STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT */
00331 
00332 #ifdef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM2_SUPPORT
00333 # undef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM2_SUPPORT
00334 #endif /* !STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM2_SUPPORT */
00335 
00336 #ifdef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT
00337 # undef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT
00338 #endif /* !STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT */
00339 
00340 #ifdef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM4_SUPPORT
00341 # undef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM4_SUPPORT
00342 #endif /* !STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM4_SUPPORT */
00343 
00344 #ifdef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM5_SUPPORT
00345 # undef STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM5_SUPPORT
00346 #endif /* !STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM5_SUPPORT */
00347 
00348 
00349 
00350 
00351 /* Determine whether we can support bidirectional iterators
00352  *
00353  * This used to be in each compiler's capability file
00354  * (include/stlsoft/internal/cccap/xxxx.h), but is moved here because it is
00355  * actually a library feature (somewhat dependent on compilers's abilities).
00356  */
00357 
00358 #if defined(STLSOFT_COMPILER_IS_BORLAND)
00359 # define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00360 #elif defined(STLSOFT_COMPILER_IS_COMO)
00361 # define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00362 #elif defined(STLSOFT_COMPILER_IS_DMC)
00363 # if (__DMC__ >= 0x0829)
00364 #  define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00365 # endif /* __DMC__ >= 0x0829 */
00366 #elif defined(STLSOFT_COMPILER_IS_GCC)
00367 # define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00368 #elif defined(STLSOFT_COMPILER_IS_INTEL)
00369 # define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00370 #elif defined(STLSOFT_COMPILER_IS_MSVC)
00371 # if _MSC_VER >= 1200
00372 #  define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00373 # endif /* _MSC_VER */
00374 #elif defined(STLSOFT_COMPILER_IS_MWERKS)
00375 # define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00376 #elif defined(STLSOFT_COMPILER_IS_SUNPRO)
00377 # if !defined(STLSOFT_CF_STD_LIBRARY_IS_SUNPRO_RW)
00378 #  define STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT
00379 # endif /* !STLSOFT_CF_STD_LIBRARY_IS_SUNPRO_RW */
00380 /* #elif defined(STLSOFT_COMPILER_IS_UNKNOWN) */
00381 /* # define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00382 #elif defined(STLSOFT_COMPILER_IS_VECTORC)
00383 /* #define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00384 #elif defined(STLSOFT_COMPILER_IS_WATCOM)
00385 /* #define STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00386 #else /* ? compiler/library */
00387 # error Compiler/library configuration not recognised. Contact Synesis Software
00388 #endif /* compiler/library */
00389 
00390 
00391 /* Obsolete definition: STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00392 #ifdef STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00393 # define STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT
00394 #else /* ? STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00395 # ifdef STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT
00396 #  undef STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT
00397 # endif /* STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00398 #endif /* STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00399 
00400 
00401 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00402 
00403 /* Form 1 / Form 5 */
00404 
00405 # if defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
00406  /* STLport is form 1 when not using the old form */
00407 #  if /* defined(__STL_CLASS_PARTIAL_SPECIALIZATION) || \
00408        */defined(_STLP_CLASS_PARTIAL_SPECIALIZATION)
00409 #   define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00410 #  else /* ?_STLP_CLASS_PARTIAL_SPECIALIZATION */
00411 #   define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM5_SUPPORT
00412 #  endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
00413 # elif defined(STLSOFT_CF_STD_LIBRARY_IS_HP_RW)
00414  /* Borland + HP/RogueWave standard library */
00415 #  define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00416 # elif defined(STLSOFT_CF_STD_LIBRARY_IS_HP_SGI_GNU)
00417  /* GCC + Gnu/FSF standard library */
00418 #  define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00419 # elif defined(STLSOFT_CF_STD_LIBRARY_IS_MSL)
00420  /* CodeWarrior + MSL */
00421 #  define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00422 # elif defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_BORLAND)
00423  /* Borland C++ + Dinkumware */
00424 #  define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00425 # elif defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC) && \
00426        ( \
00427            STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_7_0 || \
00428            STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_7_1 || \
00429            STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_8_0 || \
00430            STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_9_0 || \
00431            STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_10_0 || \
00432            0 \
00433        )
00434  /* Visual C++ + Dinkumware */
00435 #  define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT
00436 # endif /* compiler / library */
00437 
00438 /* Form 2 / Form 5 */
00439 # if defined(STLSOFT_CF_STD_LIBRARY_IS_HP_SGI)
00440  /* HP/SGI or HP/SGI/Comeau */
00441 #  if defined(__STL_CLASS_PARTIAL_SPECIALIZATION)
00442 #   define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM2_SUPPORT
00443 #  else /* ?__STL_CLASS_PARTIAL_SPECIALIZATION */
00444 #   define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM5_SUPPORT
00445 #  endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
00446 # endif /* compiler / library */
00447 
00448 /* Form 3 */
00449 # if defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC) && \
00450      ( \
00451          STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_4_2 || \
00452          STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_5_0 || \
00453          STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_6_0 || \
00454          0 \
00455      )
00456  /* Visual C++ + Dinkumware */
00457 #  define STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT
00458 # endif /* compiler / library */
00459 
00460 /* Form 4 */
00461 
00462 
00463 /* stlsoft_reverse_iterator() */
00464 # if defined(STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM1_SUPPORT) || \
00465      defined(STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM2_SUPPORT)
00466 #  define stlsoft_reverse_iterator(I, V, R, P, D)       stlsoft_ns_qual_std(reverse_iterator)<I>
00467 # elif defined(STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT)
00468 #  define stlsoft_reverse_iterator(I, V, R, P, D)       stlsoft_ns_qual_std(reverse_iterator)<I, V, R, P, D>
00469 //# elif defined(STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM4_SUPPORT)
00470 //#  define stlsoft_reverse_iterator(I, V, R, P, D)       stlsoft_ns_qual_std(reverse_iterator)<I, C, V, R, P, D>
00471 # elif defined(STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM5_SUPPORT)
00472 #  define stlsoft_reverse_iterator(I, V, R, P, D)       stlsoft_ns_qual_std(reverse_iterator)<I, V, R, D>
00473 # else
00474 #  error reverse_iterator form not recognised
00475 # endif /* compiler */
00476 
00477 /* stlsoft_reverse_bidirectional_iterator() */
00478 
00479 # if defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC) && \
00480      (   STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_4_2 || \
00481          STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_5_0 || \
00482          STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION == STLSOFT_CF_DINKUMWARE_VC_VERSION_6_0)
00483 #  define stlsoft_reverse_bidirectional_iterator(I, V, R, P, D)      stlsoft_ns_qual_std(reverse_bidirectional_iterator)<I, V, R, P, D>
00484 # elif defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT) && \
00485        !defined(_STLP_CLASS_PARTIAL_SPECIALIZATION)
00486 #  define stlsoft_reverse_bidirectional_iterator(I, V, R, P, D)      stlsoft_ns_qual_std(reverse_bidirectional_iterator)<I, V, R, P, D>
00487 # else
00488 #  define stlsoft_reverse_bidirectional_iterator(I, V, R, P, D)      stlsoft_reverse_iterator(I, V, R, P, D)
00489 # endif /*  */
00490 
00491 #endif /* STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00492 
00493 /* /////////////////////////////////////////////////////////////////////////
00494  * Iterators
00495  */
00496 
00497 // class iterator_base
00502 //
00515 template<   ss_typename_param_k C   /* iterator category */
00516         ,   ss_typename_param_k V   /* value type */
00517         ,   ss_typename_param_k D   /* distance type */
00518         ,   ss_typename_param_k P   /* pointer */
00519         ,   ss_typename_param_k R   /* reference */
00520         >
00521 struct iterator_base
00522 #if defined(STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT)
00523     : public stlsoft_ns_qual_std(iterator)<C, V, D, P, R>
00524 #elif defined(STLSOFT_ITERATOR_ITERATOR_FORM2_SUPPORT)
00525     : public stlsoft_ns_qual_std(iterator)<C, V, D>
00526 #elif defined(STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT)
00527     /* Form 3 does not provide an iterator from which we can derive */
00528 #else
00529 # error Further iterator form discrimination required
00530 #endif /* STLSOFT_ITERATOR_ITERATOR_FORM?_SUPPORT */
00531 {
00532 private:
00533 #if defined(STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT)
00534     typedef stlsoft_ns_qual_std(iterator)<C, V, D, P, R>    parent_class_type;
00535 #elif defined(STLSOFT_ITERATOR_ITERATOR_FORM2_SUPPORT)
00536     typedef stlsoft_ns_qual_std(iterator)<C, V, D>          parent_class_type;
00537 #elif defined(STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT)
00538     /* Form 3 does not provide an iterator from which we can derive */
00539     typedef void                                            parent_class_type;
00540 #else
00541 # error Further iterator form discrimination required
00542 #endif /* STLSOFT_ITERATOR_ITERATOR_FORM?_SUPPORT */
00543 
00544 
00545 # ifdef STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED_XXXX
00546 private:
00547     // iterator_category
00548     enum { has_member_iterator_category     =   0 != has_iterator_category<parent_class_type>::value    };
00549 
00550     // value_type
00551     enum { has_member_value_type            =   0 != has_value_type<parent_class_type>::value           };
00552 
00553     // distance_type
00554     enum { has_member_distance_type         =   0 != has_distance_type<parent_class_type>::value        };
00555 
00556     // pointer
00557     enum { has_member_pointer               =   0 != has_pointer<parent_class_type>::value              };
00558     enum { has_member_pointer_type          =   0 != has_pointer_type<parent_class_type>::value         };
00559 
00560     // reference
00561     enum { has_member_reference             =   0 != has_reference<parent_class_type>::value            };
00562     enum { has_member_reference_type        =   0 != has_reference_type<parent_class_type>::value       };
00563 
00564     typedef C               iterator_category_candidate;
00565     typedef V               value_type_candidate;
00566     typedef D               distance_candidate;
00567     typedef P               pointer_candidate;
00568     typedef R               reference_candidate;
00569 
00570 public:
00572     typedef ss_typename_type_k select_first_type_if<ss_typename_type_k fixer_pointer_type<parent_class_type, has_member_pointer_type>::pointer_type
00573                                                 ,   ss_typename_type_k fixer_pointer<parent_class_type, has_member_pointer>::pointer
00574                                                 ,   has_member_pointer_type
00575                                                 >::type             pointer;
00577     typedef ss_typename_type_k select_first_type_if<ss_typename_type_k fixer_reference_type<parent_class_type, has_member_reference_type>::reference_type
00578                                                 ,   ss_typename_type_k fixer_reference<parent_class_type, has_member_reference>::reference
00579                                                 ,   has_member_reference_type
00580                                                 >::type             reference;
00581 
00582 # else /* ? STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED */
00583 
00584 public:
00585 #if defined(STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT)
00586     typedef C                                                       iterator_category;
00587     typedef V                                                       value_type;
00588     typedef D                                                       difference_type;
00589     typedef P                                                       pointer;
00590     typedef R                                                       reference;
00591 #else
00592   /* Forms 1 or 2 */
00593     typedef ss_typename_type_k parent_class_type::iterator_category iterator_category;
00594     typedef ss_typename_type_k parent_class_type::value_type        value_type;
00595 # if defined(STLSOFT_ITERATOR_ITERATOR_FORM1_SUPPORT)
00596     typedef ss_typename_type_k parent_class_type::difference_type   difference_type;
00597     typedef ss_typename_type_k parent_class_type::pointer           pointer;
00598     typedef ss_typename_type_k parent_class_type::reference         reference;
00599 # elif defined(STLSOFT_ITERATOR_ITERATOR_FORM2_SUPPORT)
00600     typedef ss_typename_type_k parent_class_type::distance_type     difference_type;
00601     typedef P                                                       pointer;
00602     typedef R                                                       reference;
00603 # else
00604 #  error Further iterator form discrimination required
00605 # endif /* STLSOFT_ITERATOR_ITERATOR_FORM?_SUPPORT */
00606 #endif /* STLSOFT_ITERATOR_ITERATOR_FORM3_SUPPORT */
00607 
00608 # endif /* STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED */
00609 
00610     /* These two are for compatibility with older non-standard implementations, and
00611      * will be benignly ignored by anything not requiring them.
00612      */
00613     typedef pointer                                                 pointer_type;
00614     typedef reference                                               reference_type;
00615 };
00616 
00617 
00618 #ifdef STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT
00619 
00620 // reverse_iterator_base, const_reverse_iterator_base,
00621 // reverse_bidirectional_iterator_base and const_reverse_bidirectional_iterator_base
00622 //
00623 // These classes act as the base for reverse iterators, insulating deriving
00624 // classes from the inconsistencies and incompatibilities of the various
00625 // compilers and/or libraries supported by the STLSoft libraries.
00626 
00627 // class reverse_iterator_base
00632 //
00645 template<   ss_typename_param_k I   /* iterator */
00646         ,   ss_typename_param_k V   /* value type */
00647         ,   ss_typename_param_k R   /* reference */
00648         ,   ss_typename_param_k P   /* pointer */
00649         ,   ss_typename_param_k D   /* distance type */
00650         >
00651 struct reverse_iterator_base
00652     : public stlsoft_reverse_iterator(I, V, R, P, D)
00653 {
00654 public:
00655     typedef stlsoft_reverse_iterator(I, V, R, P, D)                 parent_class_type;
00656 
00657     typedef ss_typename_type_k parent_class_type::iterator_category iterator_category;
00658     typedef ss_typename_type_k parent_class_type::value_type        value_type;
00659 # if defined(STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT)
00660     typedef ss_typename_type_k parent_class_type::distance_type     difference_type;
00661     typedef ss_typename_type_k parent_class_type::pointer_type      pointer;
00662     typedef ss_typename_type_k parent_class_type::reference_type    reference;
00663 # else /* ? STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT */
00664     typedef ss_typename_type_k parent_class_type::difference_type   difference_type;
00665     typedef ss_typename_type_k parent_class_type::pointer           pointer;
00666     typedef ss_typename_type_k parent_class_type::reference         reference;
00667 # endif /* STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT */
00668 
00669     /* These two are for compatibility with older non-standard implementations, and
00670      * will be benignly ignored by anything not requiring them.
00671      */
00672     typedef pointer                                                 pointer_type;
00673     typedef reference                                               reference_type;
00674 
00675 // Construction
00676 public:
00678     ss_explicit_k reverse_iterator_base(I i)
00679         : parent_class_type(i)
00680     {}
00681 };
00682 
00683 // class const_reverse_iterator_base
00688 //
00701 template<   ss_typename_param_k I   /* iterator */
00702         ,   ss_typename_param_k V   /* value type */
00703         ,   ss_typename_param_k R   /* reference */
00704         ,   ss_typename_param_k P   /* pointer */
00705         ,   ss_typename_param_k D   /* distance type */
00706         >
00707 struct const_reverse_iterator_base                  // For all current compilers/libraries, ...
00708     : public reverse_iterator_base<I, V, R, P, D>   // ... this is the same as reverse_iterator_base
00709 {
00710 public:
00711     typedef reverse_iterator_base<I, V, R, P, D>                    parent_class_type;
00712 
00714     typedef ss_typename_type_k parent_class_type::iterator_category iterator_category;
00716     typedef ss_typename_type_k parent_class_type::value_type        value_type;
00718     typedef ss_typename_type_k parent_class_type::difference_type   difference_type;
00720     typedef ss_typename_type_k parent_class_type::pointer           pointer;
00722     typedef ss_typename_type_k parent_class_type::reference         reference;
00723 
00724     /* These two are for compatibility with older non-standard implementations, and
00725      * will be benignly ignored by anything not requiring them.
00726      */
00728     typedef ss_typename_type_k parent_class_type::pointer_type      pointer_type;
00730     typedef ss_typename_type_k parent_class_type::reference_type    reference_type;
00731 
00732 // Construction
00733 public:
00735     ss_explicit_k const_reverse_iterator_base(I i)
00736         : parent_class_type(i)
00737     {}
00738 
00739     // This constructor facilitates conversion from mutable (non-const)
00740     // reverse iterators
00741     template<   ss_typename_param_k I2
00742             ,   ss_typename_param_k V2
00743             ,   ss_typename_param_k R2
00744             ,   ss_typename_param_k P2
00745             ,   ss_typename_param_k D2
00746             >
00747     const_reverse_iterator_base(reverse_iterator_base<I2, V2, R2, P2, D2> const& rhs)
00748         : parent_class_type(rhs.base())
00749     {}
00750 };
00751 
00752 template<   ss_typename_param_k I1, ss_typename_param_k V1, ss_typename_param_k R1, ss_typename_param_k P1, ss_typename_param_k D
00753         ,   ss_typename_param_k I2, ss_typename_param_k V2, ss_typename_param_k R2, ss_typename_param_k P2
00754         >
00755 inline bool operator !=(
00756     const_reverse_iterator_base<I1, V1, R1, P1, D> const&   lhs
00757 ,   reverse_iterator_base<I2, V2, R2, P2, D> const&         rhs
00758 )
00759 {
00760     return lhs.base() != rhs.base();
00761 }
00762 
00763 template<   ss_typename_param_k I1, ss_typename_param_k V1, ss_typename_param_k R1, ss_typename_param_k P1, ss_typename_param_k D
00764         ,   ss_typename_param_k I2, ss_typename_param_k V2, ss_typename_param_k R2, ss_typename_param_k P2
00765         >
00766 inline bool operator !=(
00767     reverse_iterator_base<I1, V1, R1, P1, D> const&         lhs
00768 ,   const_reverse_iterator_base<I2, V2, R2, P2, D> const&   rhs
00769 )
00770 {
00771     return lhs.base() != rhs.base();
00772 }
00773 
00774 template<   ss_typename_param_k I1, ss_typename_param_k V1, ss_typename_param_k R1, ss_typename_param_k P1, ss_typename_param_k D
00775         >
00776 inline bool operator !=(
00777     const_reverse_iterator_base<I1, V1, R1, P1, D> const&   lhs
00778 ,   const_reverse_iterator_base<I1, V1, R1, P1, D> const&   rhs
00779 )
00780 {
00781     return lhs.base() != rhs.base();
00782 }
00783 
00784 
00785 // class reverse_bidirectional_iterator_base
00790 //
00803 template<   ss_typename_param_k I   /* iterator */
00804         ,   ss_typename_param_k V   /* value type */
00805         ,   ss_typename_param_k R   /* reference */
00806         ,   ss_typename_param_k P   /* pointer */
00807         ,   ss_typename_param_k D   /* distance type */
00808         >
00809 struct reverse_bidirectional_iterator_base
00810     : public stlsoft_reverse_bidirectional_iterator(I, V, R, P, D)
00811 {
00812 public:
00813     typedef stlsoft_reverse_bidirectional_iterator(I, V, R, P, D)               parent_class_type;
00814 
00815     typedef ss_typename_type_k parent_class_type::iterator_category             iterator_category;
00816     typedef ss_typename_type_k parent_class_type::value_type                    value_type;
00817 
00818 # if defined(STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT)
00819     typedef ss_typename_type_k parent_class_type::distance_type                 difference_type;
00820     typedef ss_typename_type_k parent_class_type::pointer_type                  pointer;
00821     typedef ss_typename_type_k parent_class_type::reference_type                reference;
00822 #else /* ? STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT */
00823     typedef ss_typename_type_k parent_class_type::difference_type               difference_type;
00824     typedef ss_typename_type_k parent_class_type::pointer                       pointer;
00825     typedef ss_typename_type_k parent_class_type::reference                     reference;
00826 #endif /* STLSOFT_ITERATOR_REVERSE_ITERATOR_FORM3_SUPPORT */
00827 
00828     /* These two are for compatibility with older non-standard implementations, and
00829      * will be benignly ignored by anything not requiring them.
00830      */
00831     typedef pointer                                                             pointer_type;
00832     typedef reference                                                           reference_type;
00833 
00834 // Construction
00835 public:
00837     ss_explicit_k reverse_bidirectional_iterator_base(I i)
00838         : parent_class_type(i)
00839     {}
00840 };
00841 
00842 // class const_reverse_bidirectional_iterator_base
00847 //
00860 template<   ss_typename_param_k I   /* iterator */
00861         ,   ss_typename_param_k V   /* value type */
00862         ,   ss_typename_param_k R   /* reference */
00863         ,   ss_typename_param_k P   /* pointer */
00864         ,   ss_typename_param_k D   /* distance type */
00865         >
00866 struct const_reverse_bidirectional_iterator_base                // For all current compilers/libraries, ...
00867     : public reverse_bidirectional_iterator_base<I, V, R, P, D> // ... this is the same as reverse_iterator_base
00868 {
00869 public:
00870     typedef reverse_bidirectional_iterator_base<I, V, R, P, D>                  parent_class_type;
00871 
00872     typedef ss_typename_type_k parent_class_type::iterator_category             iterator_category;
00873     typedef ss_typename_type_k parent_class_type::value_type                    value_type;
00874     typedef ss_typename_type_k parent_class_type::difference_type               difference_type;
00875     typedef ss_typename_type_k parent_class_type::pointer_type                  pointer;
00876     typedef ss_typename_type_k parent_class_type::reference_type                reference;
00877 
00878     /* These two are for compatibility with older non-standard implementations, and
00879      * will be benignly ignored by anything not requiring them.
00880      */
00881     typedef ss_typename_type_k parent_class_type::pointer                       pointer_type;
00882     typedef ss_typename_type_k parent_class_type::reference                     reference_type;
00883 
00884 // Construction
00885 public:
00887     ss_explicit_k const_reverse_bidirectional_iterator_base(I i)
00888         : parent_class_type(i)
00889     {}
00890 };
00891 
00892 #endif /* STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT */
00893 
00894 /* /////////////////////////////////////////////////////////////////////////
00895  * Random access iterator support
00896  */
00897 
00898 // This is all some hideous kludge caused by Dinkumware's standard library's
00899 // failure to leave behind any definitive discriminatable vestige of its
00900 // presence.
00901 //
00902 // The discriminators are determined in stlsoft/util/std/library_discriminator.hpp
00903 
00904 #ifdef _STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES
00905 
00906 #ifndef _STLSOFT_NO_NAMESPACE
00907 } // namespace stlsoft
00908 #endif /* _STLSOFT_NO_NAMESPACE */
00909 
00910 template<   ss_typename_param_k _Ty
00911         ,   ss_typename_param_k _Diff
00912         ,   ss_typename_param_k _Pointer
00913         ,   ss_typename_param_k _Reference
00914         ,   ss_typename_param_k _Pointer2
00915         ,   ss_typename_param_k _Reference2
00916         >
00917 class _Ptrit
00918 {
00919 public:
00920     typedef _Pointer    iterator_type;
00921 
00922 private:
00923     char    x[1024];
00924 };
00925 
00926 namespace std
00927 {
00928     namespace test_dinkumware
00929     {
00930         template<   ss_typename_param_k T1
00931                 ,   ss_typename_param_k T2
00932                 ,   bool S
00933                 >
00934         struct select_type
00935         {
00936             typedef T1  selected_type;
00937         };
00938 
00939 #ifdef STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT
00940         template<   ss_typename_param_k T1
00941                 ,   ss_typename_param_k T2
00942                 >
00943         struct select_type<T1, T2, false>
00944         {
00945             typedef T2  selected_type;
00946         };
00947 #endif // STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT
00948 
00949         template<   class V
00950                 ,   class P
00951                 ,   class R
00952                 >
00953         class _Ptrit_tdkw
00954         {
00955             typedef _Ptrit<V, stlsoft_ns_qual(ss_ptrdiff_t), P, R, P, R>    _Ptrit_type;
00956 
00957         public:
00958             typedef ss_typename_type_k select_type<_Ptrit_type, P, sizeof(_Ptrit_type) < 1024>::selected_type  iterator_type;
00959         };
00960 
00961     } // namespace test_dinkumware
00962 
00963 } // namespace std
00964 
00965 #ifndef _STLSOFT_NO_NAMESPACE
00966 namespace stlsoft
00967 {
00968 #endif /* _STLSOFT_NO_NAMESPACE */
00969 
00970 #endif /* !_STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES */
00971 
00980 template<   ss_typename_param_k V
00981         ,   ss_typename_param_k P
00982         ,   ss_typename_param_k R
00983         >
00984 struct pointer_iterator
00985 {
00986 #if defined(_STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES) && \
00987     !defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
00988 # if defined(_STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES_1300)
00989     typedef std::test_dinkumware::_Ptrit_tdkw<V, P, R>::iterator_type   type;
00990 # else
00991     typedef P                                                           type;
00992 # endif /* _STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES_1300 */
00993 #elif defined(STLSOFT_COMPILER_IS_MSVC) && \
00994       !defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT) && \
00995       defined(_XUTILITY_) && \
00996       _MSC_VER == 1300
00997     typedef std::_Ptrit<V, stlsoft_ns_qual(ss_ptrdiff_t), P, R, P, R>   type;
00998 #else
00999     typedef P                                                           type;
01000 #endif /* !_STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES */
01001 
01002 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
01003 public:
01004     // For backwards compatibility
01005     typedef type                                                        iterator_type;
01006 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
01007 };
01008 
01009 /* ////////////////////////////////////////////////////////////////////// */
01010 
01011 #if defined(STLSOFT_COMPILER_IS_DMC) && \
01012     !defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
01013 template<   ss_typename_param_k V
01014         ,   ss_typename_param_k P
01015         ,   ss_typename_param_k R
01016         >
01017 inline random_access_iterator_tag iterator_category(pointer_iterator<V, P, R>::type const&)
01018 {
01019     return random_access_iterator_tag();
01020 }
01021 
01022 template<   ss_typename_param_k V
01023         ,   ss_typename_param_k P
01024         ,   ss_typename_param_k R
01025         >
01026 inline stlsoft_ns_qual(ss_ptrdiff_t) *distance_type(pointer_iterator<V, P, R>::type const&)
01027 {
01028     return static_cast<stlsoft_ns_qual(ss_ptrdiff_t)*>(0);
01029 }
01030 #endif /* STLSOFT_COMPILER_IS_DMC  && !STLSOFT_CF_STD_LIBRARY_IS_STLPORT */
01031 
01032 /* ////////////////////////////////////////////////////////////////////// */
01033 
01042 #if defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC)
01043 # define stlsoft_iterator_query_category(I, i)      (stlsoft_ns_qual_std(_Iter_cat)(i))
01044 # define stlsoft_iterator_query_category_ptr(I, i)  (&stlsoft_ns_qual_std(_Iter_cat)(i))
01045 
01046 //#elif defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
01047 //# define stlsoft_iterator_query_category(I, i)     (*static_cast<std::iterator_traits<I>::iterator_category*>(0))
01048 
01049 //#elif defined(STLSOFT_COMPILER_IS_BORLAND) // Change this to STLSOFT_CF_STD_LIBRARY_IS_SGI_RW
01050 //# define stlsoft_iterator_query_category(I, i)     (*static_cast<std::iterator_traits<I>::iterator_category*>(0))
01051 
01052 #else /* ? library */
01053 
01054 //#if defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
01055 # define stlsoft_iterator_query_category(I, i)      (*static_cast<ss_typename_type_k std::iterator_traits<I>::iterator_category*>(0))
01056 # define stlsoft_iterator_query_category_ptr(I, i)  (static_cast<ss_typename_type_k std::iterator_traits<I>::iterator_category*>(0))
01057 //#else
01058 //#  define stlsoft_iterator_query_category(I, i)     (stlsoft_ns_qual_std(iterator_category)(i))
01059 
01060 #endif /* library / compiler */
01061 
01062 #if 0
01063 #    if defined(STLSOFT_COMPILER_IS_DMC)
01064 #     if defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
01065 #      define stlsoft_iterator_query_category(I, i)     (stlsoft_ns_qual_std(iterator_traits)<I>::iterator_category())
01066     //#  error Digital Mars with STLport not yet supported
01067 #     else
01068 #      define stlsoft_iterator_query_category(I, i)     (stlsoft_ns_qual_std(iterator_category)(i))
01069 #     endif /*  */
01070 #    elif defined(STLSOFT_COMPILER_IS_COMO) || \
01071           defined(STLSOFT_COMPILER_IS_INTEL)
01072 #     if defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
01073 #      define stlsoft_iterator_query_category(I, i)     (stlsoft_ns_qual_std(iterator_traits)<I>::iterator_category())
01074 #     elif defined(_STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES)
01075 #      define stlsoft_iterator_query_category(I, i)     (stlsoft_ns_qual_std(_Iter_cat)(i))
01076 #     else
01077 #      error
01078 #     endif /*  */
01079 #    elif defined(STLSOFT_COMPILER_IS_MSVC)
01080 #     if defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
01081 #      if _MSC_VER < 1300
01082 #       define stlsoft_iterator_query_category(I, i)    (stlsoft_ns_qual_std(iterator_category)(i))
01083 #      else
01084 #       define stlsoft_iterator_query_category(I, i)    (stlsoft_ns_qual_std(iterator_category)(i))
01085 #      endif /* _MSC_VER < 1300 */
01086 #     elif defined(_STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES)
01087 #      define stlsoft_iterator_query_category(I, i)     (stlsoft_ns_qual_std(_Iter_cat)(i))
01088 #     elif(_MSC_VER >= 1310)
01089 #      define stlsoft_iterator_query_category(I, i)     (stlsoft_ns_qual_std(iterator_traits)<I>::iterator_category())
01090 #     elif(_MSC_VER >= 1200)
01091 #      error
01092 #     endif /*  */
01093 #    else
01094 #     define stlsoft_iterator_query_category(I, i)      (stlsoft_ns_qual_std(iterator_traits)<I>::iterator_category())
01095 #    endif /* _STLSOFT_CF_MIGHT_BE_DINKUMWARE_MS_NAUGHTIES && !STLSOFT_CF_STD_LIBRARY_IS_STLPORT */
01096 #endif /* 0 */
01097 
01098 #if 0
01099 template <ss_typename_param_k T>
01100 struct queried_iterator_category
01101 {
01102 };
01103 
01104 template <ss_typename_param_k T>
01105 query_iterator_category
01106 #endif /* 0 */
01107 
01108 /* ////////////////////////////////////////////////////////////////////// */
01109 
01110 #ifndef _STLSOFT_NO_NAMESPACE
01111 } // namespace stlsoft
01112 #endif /* _STLSOFT_NO_NAMESPACE */
01113 
01114 /* ////////////////////////////////////////////////////////////////////// */
01115 
01116 #endif /* !STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER */
01117 
01118 /* ///////////////////////////// end of file //////////////////////////// */