stlsoft_meta.h

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

two_t has_value_type_function(ss_typename_type_k T::value_type const volatile *);

/// traits type used to determine whether a given type has a member \c value_type
template <ss_typename_param_k T>
struct has_value_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_value_type_function<T>(0)) == sizeof(two_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_value_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_iterator

template <ss_typename_param_k T>
one_t has_iterator_function(...);

template <ss_typename_param_k T>
three_t has_iterator_function(ss_typename_type_k T::iterator const volatile *);

/// traits type used to determine whether a given type has a member \c iterator
template <ss_typename_param_k T>
struct has_iterator
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_iterator_function<T>(0)) == sizeof(three_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_iterator<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_const_iterator

# if !defined(STLSOFT_COMPILER_IS_DMC) || \
     __DMC__ >= 0x0845 || \
     defined(STLSOFT_FORCE_HAS_REFERENCE)

template <ss_typename_param_k T>
one_t has_const_iterator_function(...);

template <ss_typename_param_k T>
four_t has_const_iterator_function(ss_typename_type_k T::const_iterator const volatile *);

/// traits type used to determine whether a given type has a member \c const_iterator
template <ss_typename_param_k T>
struct has_const_iterator
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_const_iterator_function<T>(0)) == sizeof(four_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_const_iterator<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

# endif /* compiler */

// has_pointer

template <ss_typename_param_k T>
one_t has_pointer_function(...);

template <ss_typename_param_k T>
five_t has_pointer_function(ss_typename_type_k T::pointer const volatile *);

/// traits type used to determine whether a given type has a member \c pointer
template <ss_typename_param_k T>
struct has_pointer
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_pointer_function<T>(0)) == sizeof(five_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_pointer<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_pointer_type

template <ss_typename_param_k T>
one_t has_pointer_type_function(...);

template <ss_typename_param_k T>
six_t has_pointer_type_function(ss_typename_type_k T::pointer_type const volatile *);

/// traits type used to determine whether a given type has a member \c pointer_type
template <ss_typename_param_k T>
struct has_pointer_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_pointer_type_function<T>(0)) == sizeof(six_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_pointer_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_reference

# if defined(STLSOFT_COMPILER_IS_MWERKS) || \
     defined(STLSOFT_FORCE_HAS_REFERENCE)

template <ss_typename_param_k T>
one_t has_reference_function(...);

template <ss_typename_param_k T>
seven_t has_reference_function(ss_typename_type_k T::reference const volatile *);

/// traits type used to determine whether a given type has a member \c reference
template <ss_typename_param_k T>
struct has_reference
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_reference_function<T>(0)) == sizeof(seven_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_reference<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_reference_type

template <ss_typename_param_k T>
one_t has_reference_type_function(...);

template <ss_typename_param_k T>
eight_t has_reference_type_function(ss_typename_type_k T::reference_type const volatile *);

/// traits type used to determine whether a given type has a member \c reference_type
template <ss_typename_param_k T>
struct has_reference_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_reference_type_function<T>(0)) == sizeof(eight_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_reference_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

// has_const_reference

template <ss_typename_param_k T>
one_t has_const_reference_function(...);

template <ss_typename_param_k T>
nine_t has_const_reference_function(ss_typename_type_k T::const_reference const volatile *);

/// traits type used to determine whether a given type has a member \c const_reference
template <ss_typename_param_k T>
struct has_const_reference
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_const_reference_function<T>(0)) == sizeof(nine_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_const_reference<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

# endif /* compiler */


// has_const_pointer

template <ss_typename_param_k T>
one_t has_const_pointer_function(...);

template <ss_typename_param_k T>
sixteen_t has_const_pointer_function(ss_typename_type_k T::const_pointer const volatile *);

/// traits type used to determine whether a given type has a member \c const_pointer
template <ss_typename_param_k T>
struct has_const_pointer
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_const_pointer_function<T>(0)) == sizeof(sixteen_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_const_pointer<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_iterator_category

template <ss_typename_param_k T>
one_t has_iterator_category_function(...);

template <ss_typename_param_k T>
ten_t has_iterator_category_function(ss_typename_type_k T::iterator_category const volatile *);

/// traits type used to determine whether a given type has a member \c iterator_category
template <ss_typename_param_k T>
struct has_iterator_category
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_iterator_category_function<T>(0)) == sizeof(ten_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_iterator_category<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_distance_type

template <ss_typename_param_k T>
one_t has_distance_type_function(...);

template <ss_typename_param_k T>
eleven_t has_distance_type_function(ss_typename_type_k T::distance_type const volatile *);

/// traits type used to determine whether a given type has a member \c distance_type
template <ss_typename_param_k T>
struct has_distance_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_distance_type_function<T>(0)) == sizeof(eleven_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_distance_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_difference_type

template <ss_typename_param_k T>
one_t has_difference_type_function(...);

template <ss_typename_param_k T>
twelve_t has_difference_type_function(ss_typename_type_k T::difference_type const volatile *);

/// traits type used to determine whether a given type has a member \c difference_type
template <ss_typename_param_k T>
struct has_difference_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_difference_type_function<T>(0)) == sizeof(twelve_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_difference_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_key_type

template <ss_typename_param_k T>
one_t has_key_type_function(...);

template <ss_typename_param_k T>
thirteen_t has_key_type_function(ss_typename_type_k T::key_type const volatile *);

/// traits type used to determine whether a given type has a member \c key_type
template <ss_typename_param_k T>
struct has_key_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_key_type_function<T>(0)) == sizeof(thirteen_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_key_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_mapped_type

template <ss_typename_param_k T>
one_t has_mapped_type_function(...);

template <ss_typename_param_k T>
fourteen_t has_mapped_type_function(ss_typename_type_k T::mapped_type const volatile *);

/// traits type used to determine whether a given type has a member \c mapped_type
template <ss_typename_param_k T>
struct has_mapped_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_mapped_type_function<T>(0)) == sizeof(fourteen_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_mapped_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


// has_referent_type

template <ss_typename_param_k T>
one_t has_referent_type_function(...);

template <ss_typename_param_k T>
fifteen_t has_referent_type_function(ss_typename_type_k T::referent_type const volatile *);

/// traits type used to determine whether a given type has a member \c referent_type
template <ss_typename_param_k T>
struct has_referent_type
{
    typedef T   test_type;

private:
    static T    t;
public:

    enum { value = sizeof(has_referent_type_function<T>(0)) == sizeof(fifteen_t) };
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

STLSOFT_TEMPLATE_SPECIALISATION
struct has_referent_type<void>
{
    typedef void    test_type;

    enum { value = 0 };
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */


#else /* ? compiler */

# ifdef STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED
#  undef STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED
# endif /* STLSOFT_CF_HAS_MEMBER_TYPE_SUPPORTED */

#endif /* compiler */

/* ////////////////////////////////////////////////////////////////////// */

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

/* ////////////////////////////////////////////////////////////////////// */

#endif /* !STLSOFT_INCL_H_STLSOFT_META */

/* ////////////////////////////////////////////////////////////////////// */