Page 2 of 2 FirstFirst 12
Results 26 to 34 of 34
  1. #26
    Take the fcking keys away baseline bum's Avatar
    My Team
    San Antonio Spurs
    Post Count
    93,160
    /*
    * Copyright (c) 1999
    * Silicon Graphics Computer Systems, Inc.
    *
    * Permission to use, copy, modify, distribute and sell this software
    * and its do entation for any purpose is hereby granted without fee,
    * provided that the above copyright notice appear in all copies and
    * that both that copyright notice and this permission notice appear
    * in supporting do entation. Silicon Graphics makes no
    * representations about the suitability of this software for any
    * purpose. It is provided "as is" without express or implied warranty.
    */

    #ifndef __CONCEPT_CHECKS_H
    #define __CONCEPT_CHECKS_H

    /*
    Use these macro like assertions, but they assert properties
    on types (usually template arguments). In technical terms they
    verify whether a type "models" a "concept".
    This set of requirements and the terminology used here is derived
    from the book "Generic Programming and the STL" by Matt Austern
    (Addison Wesley). For further information please consult that
    book. The requirements also are intended to match the ANSI/ISO C++
    standard.
    This file covers the basic concepts and the iterator concepts.
    There are several other files that provide the requirements
    for the STL containers:
    container_concepts.h
    sequence_concepts.h
    assoc_container_concepts.h
    Jeremy Siek, 1999
    TO DO:
    - some issues with regards to concept classification and mutability
    including AssociativeContianer -> ForwardContainer
    and SortedAssociativeContainer -> ReversibleContainer
    - HashedAssociativeContainer
    - Allocator
    - Function Object Concepts
    */

    #ifndef __STL_USE_CONCEPT_CHECKS

    // Some compilers lack the features that are necessary for concept checks.
    // On those compilers we define the concept check macros to do nothing.
    #define __STL_REQUIRES(__type_var, __concept) do {} while(0)
    #define __STL_CLASS_REQUIRES(__type_var, __concept) \
    static int __##__type_var##_##__concept
    #define __STL_CONVERTIBLE(__type_x, __type_y) do {} while(0)
    #define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0)
    #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
    static int __##__type_x##__type_y##_require_same_type
    #define __STL_GENERATOR_CHECK(__func, __ret) do {} while(0)
    #define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
    static int __##__func##__ret##_generator_check
    #define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0)
    #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
    static int __##__func##__ret##__arg##_unary_function_check
    #define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    do {} while(0)
    #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    static int __##__func##__ret##__first##__second##_binary_func tion_check
    #define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    do {} while(0)
    #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    static int __##__opname##__ret##__first##__second##_require_b inary_op

    #else /* __STL_USE_CONCEPT_CHECKS */

    // This macro tests whether the template argument "__type_var"
    // satisfies the requirements of "__concept". Here is a list of concepts
    // that we know how to check:
    // _Allocator
    // _Assignable
    // _DefaultConstructible
    // _EqualityComparable
    // _LessThanComparable
    // _TrivialIterator
    // _Inpu erator
    // _Outpu erator
    // _ForwardIterator
    // _BidirectionalIterator
    // _RandomAccessIterator
    // _Mutable_TrivialIterator
    // _Mutable_ForwardIterator
    // _Mutable_BidirectionalIterator
    // _Mutable_RandomAccessIterator

    #define __STL_REQUIRES(__type_var, __concept) \
    do { \
    void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >\
    ::__concept##_requirement_violation; __x = __x; } while (0)

    // Use this to check whether type X is convertible to type Y
    #define __STL_CONVERTIBLE(__type_x, __type_y) \
    do { \
    void (*__x)( __type_x , __type_y ) = _STL_CONVERT_ERROR< __type_x , \
    __type_y >::__type_X_is_not_convertible_to_type_Y; \
    __x = __x; } while (0)

    // Use this to test whether two template arguments are the same type
    #define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) \
    do { \
    void (*__x)( __type_x , __type_y ) = _STL_SAME_TYPE_ERROR< __type_x, \
    __type_y >::__type_X_not_same_as_type_Y; \
    __x = __x; } while (0)


    // function object checks
    #define __STL_GENERATOR_CHECK(__func, __ret) \
    do { \
    __ret (*__x)( __func&) = \
    _STL_GENERATOR_ERROR< \
    __func, __ret>::__generator_requirement_violation; \
    __x = __x; } while (0)


    #define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
    do { \
    __ret (*__x)( __func&, const __arg& ) = \
    _STL_UNARY_FUNCTION_ERROR< \
    __func, __ret, __arg>::__unary_function_requirement_violation; \
    __x = __x; } while (0)


    #define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    do { \
    __ret (*__x)( __func&, const __first&, const __second& ) = \
    _STL_BINARY_FUNCTION_ERROR< \
    __func, __ret, __first, __second>::__binary_function_requirement_violation ; \
    __x = __x; } while (0)


    #define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    do { \
    __ret (*__x)( __first&, __second& ) = _STL_BINARY##__opname##_ERROR< \
    __ret, __first, __second>::__binary_operator_requirement_violation ; \
    __ret (*__y)( const __first&, const __second& ) = \
    _STL_BINARY##__opname##_ERROR< __ret, __first, __second>:: \
    __const_binary_operator_requirement_violation; \
    __y = __y; __x = __x; } while (0)


    #ifdef __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE

    #define __STL_CLASS_REQUIRES(__type_var, __concept)
    #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y)
    #define __STL_CLASS_GENERATOR_CHECK(__func, __ret)
    #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg)
    #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second)
    #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second)

    #else

    // Use this macro inside of template classes, where you would
    // like to place requirements on the template arguments to the class
    // Warning: do not pass pointers and such (e.g. T*) in as the __type_var,
    // since the type_var is used to construct identifiers. Instead typedef
    // the pointer type, then use the typedef name for the __type_var.
    #define __STL_CLASS_REQUIRES(__type_var, __concept) \
    typedef void (* __func##__type_var##__concept)( __type_var ); \
    template <__func##__type_var##__concept _Tp1> \
    struct __dummy_struct_##__type_var##__concept { }; \
    static __dummy_struct_##__type_var##__concept< \
    __concept##_concept_specification< \
    __type_var>::__concept##_requirement_violation> \
    __dummy_ptr_##__type_var##__concept


    #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
    typedef void (* __func_##__type_x##__type_y##same_type)( __type_x, \
    __type_y ); \
    template < __func_##__type_x##__type_y##same_type _Tp1> \
    struct __dummy_struct_##__type_x##__type_y##_same_type { }; \
    static __dummy_struct_##__type_x##__type_y##_same_type< \
    _STL_SAME_TYPE_ERROR<__type_x, __type_y>::__type_X_not_same_as_type_Y> \
    __dummy_ptr_##__type_x##__type_y##_same_type


    #define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
    typedef __ret (* __f_##__func##__ret##_generator)( __func& ); \
    template <__f_##__func##__ret##_generator _Tp1> \
    struct __dummy_struct_##__func##__ret##_generator { }; \
    static __dummy_struct_##__func##__ret##_generator< \
    _STL_GENERATOR_ERROR< \
    __func, __ret>::__generator_requirement_violation> \
    __dummy_ptr_##__func##__ret##_generator


    #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
    typedef __ret (* __f_##__func##__ret##__arg##_unary_check)( __func&, \
    const __arg& ); \
    template <__f_##__func##__ret##__arg##_unary_check _Tp1> \
    struct __dummy_struct_##__func##__ret##__arg##_unary_chec k { }; \
    static __dummy_struct_##__func##__ret##__arg##_unary_chec k< \
    _STL_UNARY_FUNCTION_ERROR< \
    __func, __ret, __arg>::__unary_function_requirement_violation> \
    __dummy_ptr_##__func##__ret##__arg##_unary_check


    #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    typedef __ret (* __f_##__func##__ret##__first##__second##_binary_ch eck)( __func&, const __first&,\
    const __second& ); \
    template <__f_##__func##__ret##__first##__second##_binary_c heck _Tp1> \
    struct __dummy_struct_##__func##__ret##__first##__second# #_binary_check { }; \
    static __dummy_struct_##__func##__ret##__first##__second# #_binary_check< \
    _STL_BINARY_FUNCTION_ERROR<__func, __ret, __first, __second>:: \
    __binary_function_requirement_violation> \
    __dummy_ptr_##__func##__ret##__first##__second##_b inary_check


    #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    typedef __ret (* __f_##__func##__ret##__first##__second##_binary_op )(const __first&, \
    const __second& ); \
    template <__f_##__func##__ret##__first##__second##_binary_o p _Tp1> \
    struct __dummy_struct_##__func##__ret##__first##__second# #_binary_op { }; \
    static __dummy_struct_##__func##__ret##__first##__second# #_binary_op< \
    _STL_BINARY##__opname##_ERROR<__ret, __first, __second>:: \
    __binary_operator_requirement_violation> \
    __dummy_ptr_##__func##__ret##__first##__second##_b inary_op

    #endif

    /* helper class for finding non-const version of a type. Need to have
    something to assign to etc. when testing constant iterators. */

    template <class _Tp>
    struct _Mutable_trait {
    typedef _Tp _Type;
    };
    template <class _Tp>
    struct _Mutable_trait<const _Tp> {
    typedef _Tp _Type;
    };


    /* helper function for avoiding compiler warnings about unused variables */
    template <class _Type>
    void __sink_unused_warning(_Type) { }

    template <class _TypeX, class _TypeY>
    struct _STL_CONVERT_ERROR {
    static void
    __type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) {
    _TypeY __y = __x;
    __sink_unused_warning(__y);
    }
    };


    template <class _Type> struct __check_equal { };

    template <class _TypeX, class _TypeY>
    struct _STL_SAME_TYPE_ERROR {
    static void
    __type_X_not_same_as_type_Y(_TypeX , _TypeY ) {
    __check_equal<_TypeX> t1 = __check_equal<_TypeY>();
    }
    };


    // Some Functon Object Checks

    template <class _Func, class _Ret>
    struct _STL_GENERATOR_ERROR {
    static _Ret __generator_requirement_violation(_Func& __f) {
    return __f();
    }
    };

    template <class _Func>
    struct _STL_GENERATOR_ERROR<_Func, void> {
    static void __generator_requirement_violation(_Func& __f) {
    __f();
    }
    };


    template <class _Func, class _Ret, class _Arg>
    struct _STL_UNARY_FUNCTION_ERROR {
    static _Ret
    __unary_function_requirement_violation(_Func& __f,
    const _Arg& __arg) {
    return __f(__arg);
    }
    };

    template <class _Func, class _Arg>
    struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> {
    static void
    __unary_function_requirement_violation(_Func& __f,
    const _Arg& __arg) {
    __f(__arg);
    }
    };

    template <class _Func, class _Ret, class _First, class _Second>
    struct _STL_BINARY_FUNCTION_ERROR {
    static _Ret
    __binary_function_requirement_violation(_Func& __f,
    const _First& __first,
    const _Second& __second) {
    return __f(__first, __second);
    }
    };

    template <class _Func, class _First, class _Second>
    struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> {
    static void
    __binary_function_requirement_violation(_Func& __f,
    const _First& __first,
    const _Second& __second) {
    __f(__first, __second);
    }
    };


    #define __STL_DEFINE_BINARY_OP_CHECK(_OP, _NAME) \
    template <class _Ret, class _First, class _Second> \
    struct _STL_BINARY##_NAME##_ERROR { \
    static _Ret \
    __const_binary_operator_requirement_violation(cons t _First& __first, \
    const _Second& __second) { \
    return __first _OP __second; \
    } \
    static _Ret \
    __binary_operator_requirement_violation(_First& __first, \
    _Second& __second) { \
    return __first _OP __second; \
    } \
    }

    __STL_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN);
    __STL_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN);
    __STL_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS);
    __STL_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES);
    __STL_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE);
    __STL_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT);
    __STL_DEFINE_BINARY_OP_CHECK(%, _OP_MOD);
    // ...

    // TODO, add unary operators (prefix and postfix)

    /*
    The presence of this class is just to trick EDG into displaying
    these error messages before any other errors. Without the
    classes, the errors in the functions get reported after
    other class errors deep inside the library. The name
    choice just makes for an eye catching error message
    */
    struct _STL_ERROR {

    template <class _Type>
    static _Type
    __default_constructor_requirement_violation(_Type) {
    return _Type();
    }
    template <class _Type>
    static _Type
    __assignment_operator_requirement_violation(_Type __a) {
    __a = __a;
    return __a;
    }
    template <class _Type>
    static _Type
    __copy_constructor_requirement_violation(_Type __a) {
    _Type __c(__a);
    return __c;
    }
    template <class _Type>
    static _Type
    __const_parameter_required_for_copy_constructor(_T ype /* __a */,
    const _Type& __b) {
    _Type __c(__b);
    return __c;
    }
    template <class _Type>
    static _Type
    __const_parameter_required_for_assignment_operator (_Type __a,
    const _Type& __b) {
    __a = __b;
    return __a;
    }
    template <class _Type>
    static _Type
    __less_than_comparable_requirement_violation(_Type __a, _Type __b) {
    if (__a < __b || __a > __b || __a <= __b || __a >= __b) return __a;
    return __b;
    }
    template <class _Type>
    static _Type
    __equality_comparable_requirement_violation(_Type __a, _Type __b) {
    if (__a == __b || __a != __b) return __a;
    return __b;
    }
    template <class _Iterator>
    static void
    __dereference_operator_requirement_violation(_Iter ator __i) {
    __sink_unused_warning(*__i);
    }
    template <class _Iterator>
    static void
    __dereference_operator_and_assignment_requirement_ violation(_Iterator __i) {
    *__i = *__i;
    }
    template <class _Iterator>
    static void
    __preincrement_operator_requirement_violation(_Ite rator __i) {
    ++__i;
    }
    template <class _Iterator>
    static void
    __postincrement_operator_requirement_violation(_It erator __i) {
    __i++;
    }
    template <class _Iterator>
    static void
    __predecrement_operator_requirement_violation(_Ite rator __i) {
    --__i;
    }
    template <class _Iterator>
    static void
    __postdecrement_operator_requirement_violation(_It erator __i) {
    __i--;
    }
    template <class _Iterator, class _Type>
    static void
    __postincrement_operator_and_assignment_requiremen t_violation(_Iterator __i,
    _Type __t) {
    *__i++ = __t;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_addition_assignment_requirement_violati on(_Iterator __i,
    _Distance __n) {
    __i += __n;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_addition_requirement_violation(_Iterato r __i, _Distance __n) {
    __i = __i + __n;
    __i = __n + __i;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_subtraction_assignment_requirement_viol ation(_Iterator __i,
    _Distance __n) {
    __i -= __n;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_subtraction_requirement_violation(_Iter ator __i, _Distance __n) {
    __i = __i - __n;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Distance
    __difference_operator_requirement_violation(_Itera tor __i, _Iterator __j,
    _Distance __n) {
    __n = __i - __j;
    return __n;
    }
    template <class _Exp, class _Type, class _Distance>
    static _Type
    __element_access_operator_requirement_violation(_E xp __x, _Type*,
    _Distance __n) {
    return __x[__n];
    }
    template <class _Exp, class _Type, class _Distance>
    static void
    __element_assignment_operator_requirement_violatio n(_Exp __x,
    _Type* __t,
    _Distance __n) {
    __x[__n] = *__t;
    }

    }; /* _STL_ERROR */

    /* Associated Type Requirements */

    __STL_BEGIN_NAMESPACE
    template <class _Iterator> struct iterator_traits;
    __STL_END_NAMESPACE

    template <class _Iter>
    struct __value_type_type_definition_requirement_violation {
    typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
    };

    template <class _Iter>
    struct __difference_type_type_definition_requirement_viol ation {
    typedef typename __STD::iterator_traits<_Iter>::difference_type
    difference_type;
    };

    template <class _Iter>
    struct __reference_type_definition_requirement_violation {
    typedef typename __STD::iterator_traits<_Iter>::reference reference;
    };

    template <class _Iter>
    struct __pointer_type_definition_requirement_violation {
    typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
    };

    template <class _Iter>
    struct __iterator_category_type_definition_requirement_vi olation {
    typedef typename __STD::iterator_traits<_Iter>::iterator_category
    iterator_category;
    };

    /* Assignable Requirements */


    template <class _Type>
    struct _Assignable_concept_specification {
    static void _Assignable_requirement_violation(_Type __a) {
    _STL_ERROR::__assignment_operator_requirement_viol ation(__a);
    _STL_ERROR::__copy_constructor_requirement_violati on(__a);
    _STL_ERROR::__const_parameter_required_for_copy_co nstructor(__a,__a);
    _STL_ERROR::__const_parameter_required_for_assignm ent_operator(__a,__a);
    }
    };

    /* DefaultConstructible Requirements */


    template <class _Type>
    struct _DefaultConstructible_concept_specification {
    static void _DefaultConstructible_requirement_violation(_Type __a) {
    _STL_ERROR::__default_constructor_requirement_viol ation(__a);
    }
    };

    /* EqualityComparable Requirements */

    template <class _Type>
    struct _EqualityComparable_concept_specification {
    static void _EqualityComparable_requirement_violation(_Type __a) {
    _STL_ERROR::__equality_comparable_requirement_viol ation(__a, __a);
    }
    };

    /* LessThanComparable Requirements */
    template <class _Type>
    struct _LessThanComparable_concept_specification {
    static void _LessThanComparable_requirement_violation(_Type __a) {
    _STL_ERROR::__less_than_comparable_requirement_vio lation(__a, __a);
    }
    };

    /* TrivialIterator Requirements */
    ..

  2. #27
    Veteran Fabbs's Avatar
    My Team
    San Antonio Spurs
    Post Count
    15,566

    I'll keep bumping this thread for as long as Fabbs triggers me.

  3. #28
    Take the fcking keys away baseline bum's Avatar
    My Team
    San Antonio Spurs
    Post Count
    93,160
    /*
    * Copyright (c) 1999
    * Silicon Graphics Computer Systems, Inc.
    *
    * Permission to use, copy, modify, distribute and sell this software
    * and its do entation for any purpose is hereby granted without fee,
    * provided that the above copyright notice appear in all copies and
    * that both that copyright notice and this permission notice appear
    * in supporting do entation. Silicon Graphics makes no
    * representations about the suitability of this software for any
    * purpose. It is provided "as is" without express or implied warranty.
    */

    #ifndef __CONCEPT_CHECKS_H
    #define __CONCEPT_CHECKS_H

    /*
    Use these macro like assertions, but they assert properties
    on types (usually template arguments). In technical terms they
    verify whether a type "models" a "concept".
    This set of requirements and the terminology used here is derived
    from the book "Generic Programming and the STL" by Matt Austern
    (Addison Wesley). For further information please consult that
    book. The requirements also are intended to match the ANSI/ISO C++
    standard.
    This file covers the basic concepts and the iterator concepts.
    There are several other files that provide the requirements
    for the STL containers:
    container_concepts.h
    sequence_concepts.h
    assoc_container_concepts.h
    Jeremy Siek, 1999
    TO DO:
    - some issues with regards to concept classification and mutability
    including AssociativeContianer -> ForwardContainer
    and SortedAssociativeContainer -> ReversibleContainer
    - HashedAssociativeContainer
    - Allocator
    - Function Object Concepts
    */

    #ifndef __STL_USE_CONCEPT_CHECKS

    // Some compilers lack the features that are necessary for concept checks.
    // On those compilers we define the concept check macros to do nothing.
    #define __STL_REQUIRES(__type_var, __concept) do {} while(0)
    #define __STL_CLASS_REQUIRES(__type_var, __concept) \
    static int __##__type_var##_##__concept
    #define __STL_CONVERTIBLE(__type_x, __type_y) do {} while(0)
    #define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0)
    #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
    static int __##__type_x##__type_y##_require_same_type
    #define __STL_GENERATOR_CHECK(__func, __ret) do {} while(0)
    #define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
    static int __##__func##__ret##_generator_check
    #define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0)
    #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
    static int __##__func##__ret##__arg##_unary_function_check
    #define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    do {} while(0)
    #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    static int __##__func##__ret##__first##__second##_binary_func tion_check
    #define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    do {} while(0)
    #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    static int __##__opname##__ret##__first##__second##_require_b inary_op

    #else /* __STL_USE_CONCEPT_CHECKS */

    // This macro tests whether the template argument "__type_var"
    // satisfies the requirements of "__concept". Here is a list of concepts
    // that we know how to check:
    // _Allocator
    // _Assignable
    // _DefaultConstructible
    // _EqualityComparable
    // _LessThanComparable
    // _TrivialIterator
    // _Inpu erator
    // _Outpu erator
    // _ForwardIterator
    // _BidirectionalIterator
    // _RandomAccessIterator
    // _Mutable_TrivialIterator
    // _Mutable_ForwardIterator
    // _Mutable_BidirectionalIterator
    // _Mutable_RandomAccessIterator

    #define __STL_REQUIRES(__type_var, __concept) \
    do { \
    void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >\
    ::__concept##_requirement_violation; __x = __x; } while (0)

    // Use this to check whether type X is convertible to type Y
    #define __STL_CONVERTIBLE(__type_x, __type_y) \
    do { \
    void (*__x)( __type_x , __type_y ) = _STL_CONVERT_ERROR< __type_x , \
    __type_y >::__type_X_is_not_convertible_to_type_Y; \
    __x = __x; } while (0)

    // Use this to test whether two template arguments are the same type
    #define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) \
    do { \
    void (*__x)( __type_x , __type_y ) = _STL_SAME_TYPE_ERROR< __type_x, \
    __type_y >::__type_X_not_same_as_type_Y; \
    __x = __x; } while (0)


    // function object checks
    #define __STL_GENERATOR_CHECK(__func, __ret) \
    do { \
    __ret (*__x)( __func&) = \
    _STL_GENERATOR_ERROR< \
    __func, __ret>::__generator_requirement_violation; \
    __x = __x; } while (0)


    #define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
    do { \
    __ret (*__x)( __func&, const __arg& ) = \
    _STL_UNARY_FUNCTION_ERROR< \
    __func, __ret, __arg>::__unary_function_requirement_violation; \
    __x = __x; } while (0)


    #define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    do { \
    __ret (*__x)( __func&, const __first&, const __second& ) = \
    _STL_BINARY_FUNCTION_ERROR< \
    __func, __ret, __first, __second>::__binary_function_requirement_violation ; \
    __x = __x; } while (0)


    #define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    do { \
    __ret (*__x)( __first&, __second& ) = _STL_BINARY##__opname##_ERROR< \
    __ret, __first, __second>::__binary_operator_requirement_violation ; \
    __ret (*__y)( const __first&, const __second& ) = \
    _STL_BINARY##__opname##_ERROR< __ret, __first, __second>:: \
    __const_binary_operator_requirement_violation; \
    __y = __y; __x = __x; } while (0)


    #ifdef __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE

    #define __STL_CLASS_REQUIRES(__type_var, __concept)
    #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y)
    #define __STL_CLASS_GENERATOR_CHECK(__func, __ret)
    #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg)
    #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second)
    #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second)

    #else

    // Use this macro inside of template classes, where you would
    // like to place requirements on the template arguments to the class
    // Warning: do not pass pointers and such (e.g. T*) in as the __type_var,
    // since the type_var is used to construct identifiers. Instead typedef
    // the pointer type, then use the typedef name for the __type_var.
    #define __STL_CLASS_REQUIRES(__type_var, __concept) \
    typedef void (* __func##__type_var##__concept)( __type_var ); \
    template <__func##__type_var##__concept _Tp1> \
    struct __dummy_struct_##__type_var##__concept { }; \
    static __dummy_struct_##__type_var##__concept< \
    __concept##_concept_specification< \
    __type_var>::__concept##_requirement_violation> \
    __dummy_ptr_##__type_var##__concept


    #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
    typedef void (* __func_##__type_x##__type_y##same_type)( __type_x, \
    __type_y ); \
    template < __func_##__type_x##__type_y##same_type _Tp1> \
    struct __dummy_struct_##__type_x##__type_y##_same_type { }; \
    static __dummy_struct_##__type_x##__type_y##_same_type< \
    _STL_SAME_TYPE_ERROR<__type_x, __type_y>::__type_X_not_same_as_type_Y> \
    __dummy_ptr_##__type_x##__type_y##_same_type


    #define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
    typedef __ret (* __f_##__func##__ret##_generator)( __func& ); \
    template <__f_##__func##__ret##_generator _Tp1> \
    struct __dummy_struct_##__func##__ret##_generator { }; \
    static __dummy_struct_##__func##__ret##_generator< \
    _STL_GENERATOR_ERROR< \
    __func, __ret>::__generator_requirement_violation> \
    __dummy_ptr_##__func##__ret##_generator


    #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
    typedef __ret (* __f_##__func##__ret##__arg##_unary_check)( __func&, \
    const __arg& ); \
    template <__f_##__func##__ret##__arg##_unary_check _Tp1> \
    struct __dummy_struct_##__func##__ret##__arg##_unary_chec k { }; \
    static __dummy_struct_##__func##__ret##__arg##_unary_chec k< \
    _STL_UNARY_FUNCTION_ERROR< \
    __func, __ret, __arg>::__unary_function_requirement_violation> \
    __dummy_ptr_##__func##__ret##__arg##_unary_check


    #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
    typedef __ret (* __f_##__func##__ret##__first##__second##_binary_ch eck)( __func&, const __first&,\
    const __second& ); \
    template <__f_##__func##__ret##__first##__second##_binary_c heck _Tp1> \
    struct __dummy_struct_##__func##__ret##__first##__second# #_binary_check { }; \
    static __dummy_struct_##__func##__ret##__first##__second# #_binary_check< \
    _STL_BINARY_FUNCTION_ERROR<__func, __ret, __first, __second>:: \
    __binary_function_requirement_violation> \
    __dummy_ptr_##__func##__ret##__first##__second##_b inary_check


    #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
    typedef __ret (* __f_##__func##__ret##__first##__second##_binary_op )(const __first&, \
    const __second& ); \
    template <__f_##__func##__ret##__first##__second##_binary_o p _Tp1> \
    struct __dummy_struct_##__func##__ret##__first##__second# #_binary_op { }; \
    static __dummy_struct_##__func##__ret##__first##__second# #_binary_op< \
    _STL_BINARY##__opname##_ERROR<__ret, __first, __second>:: \
    __binary_operator_requirement_violation> \
    __dummy_ptr_##__func##__ret##__first##__second##_b inary_op

    #endif

    /* helper class for finding non-const version of a type. Need to have
    something to assign to etc. when testing constant iterators. */

    template <class _Tp>
    struct _Mutable_trait {
    typedef _Tp _Type;
    };
    template <class _Tp>
    struct _Mutable_trait<const _Tp> {
    typedef _Tp _Type;
    };


    /* helper function for avoiding compiler warnings about unused variables */
    template <class _Type>
    void __sink_unused_warning(_Type) { }

    template <class _TypeX, class _TypeY>
    struct _STL_CONVERT_ERROR {
    static void
    __type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) {
    _TypeY __y = __x;
    __sink_unused_warning(__y);
    }
    };


    template <class _Type> struct __check_equal { };

    template <class _TypeX, class _TypeY>
    struct _STL_SAME_TYPE_ERROR {
    static void
    __type_X_not_same_as_type_Y(_TypeX , _TypeY ) {
    __check_equal<_TypeX> t1 = __check_equal<_TypeY>();
    }
    };


    // Some Functon Object Checks

    template <class _Func, class _Ret>
    struct _STL_GENERATOR_ERROR {
    static _Ret __generator_requirement_violation(_Func& __f) {
    return __f();
    }
    };

    template <class _Func>
    struct _STL_GENERATOR_ERROR<_Func, void> {
    static void __generator_requirement_violation(_Func& __f) {
    __f();
    }
    };


    template <class _Func, class _Ret, class _Arg>
    struct _STL_UNARY_FUNCTION_ERROR {
    static _Ret
    __unary_function_requirement_violation(_Func& __f,
    const _Arg& __arg) {
    return __f(__arg);
    }
    };

    template <class _Func, class _Arg>
    struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> {
    static void
    __unary_function_requirement_violation(_Func& __f,
    const _Arg& __arg) {
    __f(__arg);
    }
    };

    template <class _Func, class _Ret, class _First, class _Second>
    struct _STL_BINARY_FUNCTION_ERROR {
    static _Ret
    __binary_function_requirement_violation(_Func& __f,
    const _First& __first,
    const _Second& __second) {
    return __f(__first, __second);
    }
    };

    template <class _Func, class _First, class _Second>
    struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> {
    static void
    __binary_function_requirement_violation(_Func& __f,
    const _First& __first,
    const _Second& __second) {
    __f(__first, __second);
    }
    };


    #define __STL_DEFINE_BINARY_OP_CHECK(_OP, _NAME) \
    template <class _Ret, class _First, class _Second> \
    struct _STL_BINARY##_NAME##_ERROR { \
    static _Ret \
    __const_binary_operator_requirement_violation(cons t _First& __first, \
    const _Second& __second) { \
    return __first _OP __second; \
    } \
    static _Ret \
    __binary_operator_requirement_violation(_First& __first, \
    _Second& __second) { \
    return __first _OP __second; \
    } \
    }

    __STL_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN);
    __STL_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN);
    __STL_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL);
    __STL_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS);
    __STL_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES);
    __STL_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE);
    __STL_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT);
    __STL_DEFINE_BINARY_OP_CHECK(%, _OP_MOD);
    // ...

    // TODO, add unary operators (prefix and postfix)

    /*
    The presence of this class is just to trick EDG into displaying
    these error messages before any other errors. Without the
    classes, the errors in the functions get reported after
    other class errors deep inside the library. The name
    choice just makes for an eye catching error message
    */
    struct _STL_ERROR {

    template <class _Type>
    static _Type
    __default_constructor_requirement_violation(_Type) {
    return _Type();
    }
    template <class _Type>
    static _Type
    __assignment_operator_requirement_violation(_Type __a) {
    __a = __a;
    return __a;
    }
    template <class _Type>
    static _Type
    __copy_constructor_requirement_violation(_Type __a) {
    _Type __c(__a);
    return __c;
    }
    template <class _Type>
    static _Type
    __const_parameter_required_for_copy_constructor(_T ype /* __a */,
    const _Type& __b) {
    _Type __c(__b);
    return __c;
    }
    template <class _Type>
    static _Type
    __const_parameter_required_for_assignment_operator (_Type __a,
    const _Type& __b) {
    __a = __b;
    return __a;
    }
    template <class _Type>
    static _Type
    __less_than_comparable_requirement_violation(_Type __a, _Type __b) {
    if (__a < __b || __a > __b || __a <= __b || __a >= __b) return __a;
    return __b;
    }
    template <class _Type>
    static _Type
    __equality_comparable_requirement_violation(_Type __a, _Type __b) {
    if (__a == __b || __a != __b) return __a;
    return __b;
    }
    template <class _Iterator>
    static void
    __dereference_operator_requirement_violation(_Iter ator __i) {
    __sink_unused_warning(*__i);
    }
    template <class _Iterator>
    static void
    __dereference_operator_and_assignment_requirement_ violation(_Iterator __i) {
    *__i = *__i;
    }
    template <class _Iterator>
    static void
    __preincrement_operator_requirement_violation(_Ite rator __i) {
    ++__i;
    }
    template <class _Iterator>
    static void
    __postincrement_operator_requirement_violation(_It erator __i) {
    __i++;
    }
    template <class _Iterator>
    static void
    __predecrement_operator_requirement_violation(_Ite rator __i) {
    --__i;
    }
    template <class _Iterator>
    static void
    __postdecrement_operator_requirement_violation(_It erator __i) {
    __i--;
    }
    template <class _Iterator, class _Type>
    static void
    __postincrement_operator_and_assignment_requiremen t_violation(_Iterator __i,
    _Type __t) {
    *__i++ = __t;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_addition_assignment_requirement_violati on(_Iterator __i,
    _Distance __n) {
    __i += __n;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_addition_requirement_violation(_Iterato r __i, _Distance __n) {
    __i = __i + __n;
    __i = __n + __i;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_subtraction_assignment_requirement_viol ation(_Iterator __i,
    _Distance __n) {
    __i -= __n;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Iterator
    __iterator_subtraction_requirement_violation(_Iter ator __i, _Distance __n) {
    __i = __i - __n;
    return __i;
    }
    template <class _Iterator, class _Distance>
    static _Distance
    __difference_operator_requirement_violation(_Itera tor __i, _Iterator __j,
    _Distance __n) {
    __n = __i - __j;
    return __n;
    }
    template <class _Exp, class _Type, class _Distance>
    static _Type
    __element_access_operator_requirement_violation(_E xp __x, _Type*,
    _Distance __n) {
    return __x[__n];
    }
    template <class _Exp, class _Type, class _Distance>
    static void
    __element_assignment_operator_requirement_violatio n(_Exp __x,
    _Type* __t,
    _Distance __n) {
    __x[__n] = *__t;
    }

    }; /* _STL_ERROR */

    /* Associated Type Requirements */

    __STL_BEGIN_NAMESPACE
    template <class _Iterator> struct iterator_traits;
    __STL_END_NAMESPACE

    template <class _Iter>
    struct __value_type_type_definition_requirement_violation {
    typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
    };

    template <class _Iter>
    struct __difference_type_type_definition_requirement_viol ation {
    typedef typename __STD::iterator_traits<_Iter>::difference_type
    difference_type;
    };

    template <class _Iter>
    struct __reference_type_definition_requirement_violation {
    typedef typename __STD::iterator_traits<_Iter>::reference reference;
    };

    template <class _Iter>
    struct __pointer_type_definition_requirement_violation {
    typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
    };

    template <class _Iter>
    struct __iterator_category_type_definition_requirement_vi olation {
    typedef typename __STD::iterator_traits<_Iter>::iterator_category
    iterator_category;
    };

    /* Assignable Requirements */


    template <class _Type>
    struct _Assignable_concept_specification {
    static void _Assignable_requirement_violation(_Type __a) {
    _STL_ERROR::__assignment_operator_requirement_viol ation(__a);
    _STL_ERROR::__copy_constructor_requirement_violati on(__a);
    _STL_ERROR::__const_parameter_required_for_copy_co nstructor(__a,__a);
    _STL_ERROR::__const_parameter_required_for_assignm ent_operator(__a,__a);
    }
    };

    /* DefaultConstructible Requirements */


    template <class _Type>
    struct _DefaultConstructible_concept_specification {
    static void _DefaultConstructible_requirement_violation(_Type __a) {
    _STL_ERROR::__default_constructor_requirement_viol ation(__a);
    }
    };

    /* EqualityComparable Requirements */

    template <class _Type>
    struct _EqualityComparable_concept_specification {
    static void _EqualityComparable_requirement_violation(_Type __a) {
    _STL_ERROR::__equality_comparable_requirement_viol ation(__a, __a);
    }
    };

    /* LessThanComparable Requirements */
    template <class _Type>
    struct _LessThanComparable_concept_specification {
    static void _LessThanComparable_requirement_violation(_Type __a) {
    _STL_ERROR::__less_than_comparable_requirement_vio lation(__a, __a);
    }
    };

    /* TrivialIterator Requirements */

  4. #29
    6X ST MVP
    My Team
    San Antonio Spurs
    Post Count
    81,091
    I thought the mods put a stop to this sh**.

  5. #30
    Veteran Fabbs's Avatar
    My Team
    San Antonio Spurs
    Post Count
    15,566
    I thought the mods put a stop to this sh**.
    Self appointed Thought Controlling others threads he doesn't agree with?
    Meh he's probably either a mod or blows one.

    If Kwa came back (super highly unlikely I know), but combined with the top Twinky being out, it's certainly possible the Spurs could win.

  6. #31
    Believe. ECOV's Avatar
    My Team
    San Antonio Spurs
    Post Count
    756
    error

  7. #32
    Savvy Veteran spurraider21's Avatar
    My Team
    San Antonio Spurs
    Post Count
    96,026
    the shills are at it again Cosmored

  8. #33
    Veteran Fabbs's Avatar
    My Team
    San Antonio Spurs
    Post Count
    15,566
    bump it up got cause the Spurs are still alive.

  9. #34
    Veteran Fabbs's Avatar
    My Team
    San Antonio Spurs
    Post Count
    15,566
    I'll tattoo on my balls

    The Laundry Krew Rules

Thread Information

Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •