adapted_iterator_traits.hpp

用STL的方式封装了WindowsAPI、COM调用、ACE、ATL、MFC、WTL等多种组件

/* /////////////////////////////////////////////////////////////////////////
 * File:        stlsoft/iterators/adapted_iterator_traits.hpp (formerly part of stlsoft/iterators/filter_iterator.hpp)
 *
 * Purpose:     Traits for detecting characteristics of adapted iterators.
 *
 * Created:     9th July 2004
 * Updated:     10th June 2006
 *
 * Home:        http://stlsoft.org/
 *
 * Copyright (c) 2004-2006, Matthew Wilson and Synesis Software
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
 *   any contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * ////////////////////////////////////////////////////////////////////// */


/// \file stlsoft/iterators/adapted_iterator_traits.hpp
///
/// Traits for detecting characteristics of adapted iterators.

#ifndef STLSOFT_INCL_STLSOFT_ITERATORS_HPP_ADAPTED_ITERATOR_TRAITS
#define STLSOFT_INCL_STLSOFT_ITERATORS_HPP_ADAPTED_ITERATOR_TRAITS

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
# define STLSOFT_VER_STLSOFT_ITERATORS_HPP_ADAPTED_ITERATOR_TRAITS_MAJOR    2
# define STLSOFT_VER_STLSOFT_ITERATORS_HPP_ADAPTED_ITERATOR_TRAITS_MINOR    4
# define STLSOFT_VER_STLSOFT_ITERATORS_HPP_ADAPTED_ITERATOR_TRAITS_REVISION 5
# define STLSOFT_VER_STLSOFT_ITERATORS_HPP_ADAPTED_ITERATOR_TRAITS_EDIT     36
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * Compatibility
 */

/*
[Incompatibilies-start]
STLSOFT_COMPILER_IS_BORLAND:
STLSOFT_COMPILER_IS_MSVC:       _MSC_VER < 1310
STLSOFT_COMPILER_IS_WATCOM:
[Incompatibilies-end]
 */

/* /////////////////////////////////////////////////////////////////////////
 * Includes
 */

#ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
# include <stlsoft/stlsoft.h>
#endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */
#ifndef STLSOFT_INCL_STLSOFT_HPP_ITERATOR
# include <stlsoft/iterator.hpp>      // for stlsoft::iterator, and macros
#endif /* !STLSOFT_INCL_STLSOFT_HPP_ITERATOR */
#ifndef STLSOFT_INCL_STLSOFT_HPP_META
# include <stlsoft/meta.hpp>
#endif /* !STLSOFT_INCL_STLSOFT_HPP_META */
#if !defined(STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED)
# error This file is not compatible with compilers that do not support member type detection
#else /* ? STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED */
# ifndef STLSOFT_INCL_STLSOFT_META_HPP_MEMBER_TRAITS
#  include <stlsoft/meta/member_traits.hpp>
# endif /* !STLSOFT_INCL_STLSOFT_META_HPP_MEMBER_TRAITS */
# ifndef STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE
#  include <stlsoft/meta/is_same_type.hpp>
# endif /* !STLSOFT_INCL_STLSOFT_META_HPP_IS_SAME_TYPE */
# ifndef STLSOFT_INCL_STLSOFT_META_HPP_BASE_TYPE_TRAITS
#  include <stlsoft/meta/base_type_traits.hpp>
# endif /* !STLSOFT_INCL_STLSOFT_META_HPP_BASE_TYPE_TRAITS */
# ifndef STLSOFT_INCL_STLSOFT_META_HPP_ADD_QUALIFIER
#  include <stlsoft/meta/add_qualifier.hpp>
# endif /* !STLSOFT_INCL_STLSOFT_META_HPP_ADD_QUALIFIER */
# ifndef STLSOFT_INCL_STLSOFT_TYPEFIXER_HPP_DIFFERENCE_TYPE
#  include <stlsoft/typefixer/difference_type.hpp>
# endif /* !STLSOFT_INCL_STLSOFT_TYPEFIXER_HPP_DIFFERENCE_TYPE */
# ifndef STLSOFT_INCL_STLSOFT_TYPEFIXER_HPP_POINTER
#  include <stlsoft/typefixer/pointer.hpp>
# endif /* !STLSOFT_INCL_STLSOFT_TYPEFIXER_HPP_POINTER */
# ifndef STLSOFT_INCL_STLSOFT_TYPEFIXER_HPP_REFERENCE
#  include <stlsoft/typefixer/reference.hpp>
# endif /* !STLSOFT_INCL_STLSOFT_TYPEFIXER_HPP_REFERENCE */
#endif /* !STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED */

#if defined(STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT) && \
    defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC) && \
    STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION < STLSOFT_CF_DINKUMWARE_VC_VERSION_7_1
# ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_DINKUMWARE_ITERATOR_TRAITS
#  include <stlsoft/util/std/dinkumware_iterator_traits.hpp>
# endif /* STLSOFT_INCL_STLSOFT_UTIL_STD_DINKUMWARE_ITERATOR_TRAITS */
#endif /* partial-specialisation && old-dinkumware */

/* /////////////////////////////////////////////////////////////////////////
 * Namespace
 */

#ifndef _STLSOFT_NO_NAMESPACE
namespace stlsoft
{
#endif /* _STLSOFT_NO_NAMESPACE */

/* /////////////////////////////////////////////////////////////////////////
 * Classes
 */

#ifdef STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT

/// Traits for adapted_iterator_traits
template <ss_typename_param_k I>
struct adapted_iterator_traits
{
private:
    // Because adapted_iterator_traits may need to work with By-Value Temporary References (which must be denoted by
    // having pointer and reference of type void), we need to detect this, and define pointer and iterator
    // (and const_pointer and const_reference) members appropriately

    enum { HAS_MEMBER_DIFFERENCE_TYPE   =   0 != member_traits<I>::has_member_difference_type               };
    enum { HAS_MEMBER_POINTER           =   0 != member_traits<I>::has_member_pointer                       };
#if defined(STLSOFT_COMPILER_IS_MWERKS)
    enum { HAS_MEMBER_REFERENCE         =   0 != member_traits<I>::has_member_reference                     };
#else /* ? compiler */
    enum { HAS_MEMBER_REFERENCE         =   HAS_MEMBER_POINTER                                              };
#endif /* compiler */

    public:
    enum { IS_DINKUMWARE_OLD_FORM       =   0 != member_traits<I>::has_member_distance_type &&
                                            0 == HAS_MEMBER_DIFFERENCE_TYPE                                 };
    private:

public:
    /// \brief The iterator category
    ///
    /// This is simply the member \c iterator_category of the adapted iterator type
    typedef ss_typename_type_k I::iterator_category                                     iterator_category;
    /// \brief The value type
    ///
    /// This is simply the member \c value_type of the adapted iterator type
    typedef ss_typename_type_k I::value_type                                            value_type;
    /// \brief The difference type
    ///
    /// This is the member \c value_type of the adapted iterator type, if it is defined, or \c ptrdiff_t if not.
    typedef ss_typename_type_k select_first_type_if<ss_typename_type_k typefixer::fixer_difference_type<I, HAS_MEMBER_DIFFERENCE_TYPE>::difference_type
                                                ,   ss_ptrdiff_t
                                                ,   HAS_MEMBER_DIFFERENCE_TYPE
                                                >::type                                 difference_type;
private:
# if defined(STLSOFT_CF_STD_LIBRARY_IS_DINKUMWARE_VC) && \
     STLSOFT_CF_STD_LIBRARY_DINKUMWARE_VC_VERSION < STLSOFT_CF_DINKUMWARE_VC_VERSION_7_1
    /// \brief The Dinkumware list::/set::(const_)iterator's putative pointer type
    typedef ss_typename_type_k select_first_type_if<value_type const *
                                                ,   value_type *
                                                ,   Dinkumware_iterator_test<I, IS_DINKUMWARE_OLD_FORM>::is_const
                                                >::type                                 putative_dinkumware_pointer_;
    /// \brief The Dinkumware list::/set::(const_)iterator's putative reference type
    typedef ss_typename_type_k select_first_type_if<value_type const &
                                                ,   value_type &
                                                ,   Dinkumware_iterator_test<I, IS_DINKUMWARE_OLD_FORM>::is_const
                                                >::type                                 putative_dinkumware_reference_;

    /// \brief The putative pointer type
    ///
    /// This is either the putative Dinkumware pointer, or the actual member pointer
    typedef ss_typename_type_k select_first_type_if<putative_dinkumware_pointer_
                                                ,   ss_typename_type_k typefixer::fixer_pointer<I, HAS_MEMBER_POINTER>::pointer
                                                ,   IS_DINKUMWARE_OLD_FORM
                                                >::type                                 putative_pointer_;
    /// \brief The putative reference type
    ///
    /// This is either the putative Dinkumware reference, or the actual member reference
    typedef ss_typename_type_k select_first_type_if<putative_dinkumware_reference_
                                                ,   ss_typename_type_k typefixer::fixer_reference<I, HAS_MEMBER_POINTER>::reference
                                                ,   IS_DINKUMWARE_OLD_FORM
                                                >::type                                 putative_reference_;
# else /* ? Dinkumware */
    typedef ss_typename_type_k typefixer::fixer_pointer<I, HAS_MEMBER_POINTER>::pointer         putative_pointer_;
    typedef ss_typename_type_k typefixer::fixer_reference<I, HAS_MEMBER_REFERENCE>::reference   putative_reference_;
# endif /* Dinkumware */
public:
    /// \brief The pointer type
    ///
    /// This is the member \c pointer of the adapted iterator type, if it is defined. If not, it is defined to
    /// be \c void, so as to prevent any dangerous use of it. This will likely act as a compile-time constraint
    /// to prevent the base iterator type being adapted (which is nice).